BaseTypeVisitor (checker-framework 3.7.0 API)

java.lang.Object
- com.sun.source.util.TreeScanner<R,P>
- - com.sun.source.util.TreePathScanner<R,P>
  - - org.checkerframework.framework.source.SourceVisitor<Void,Void>
    - - org.checkerframework.common.basetype.BaseTypeVisitor<Factory>

All Implemented Interfaces:

TreeVisitor<Void,Void>

Direct Known Subclasses:

AccumulationVisitor, AliasingVisitor, ClassValVisitor, FenumVisitor, FormatterVisitor, GuiEffectVisitor, I18nFormatterVisitor, InitializationVisitor, InterningVisitor, LessThanVisitor, LockVisitor, LowerBoundVisitor, MethodValVisitor, OptionalVisitor, RegexVisitor, ReportVisitor, ReturnsReceiverVisitor, SameLenVisitor, SignednessVisitor, TaintingVisitor, TypeOutputtingChecker.Visitor, UnitsVisitor, UpperBoundVisitor, ValueVisitor
```
public class BaseTypeVisitor<Factory extends GenericAnnotatedTypeFactory<?,?,?,?>>
extends SourceVisitor<Void,Void>
```
A SourceVisitor that performs assignment and pseudo-assignment checking, method invocation checking, and assignability checking.
This implementation uses the AnnotatedTypeFactory implementation provided by an associated BaseTypeChecker; its visitor methods will invoke this factory on parts of the AST to determine the "annotated type" of an expression. Then, the visitor methods will check the types in assignments and pseudo-assignments using commonAssignmentCheck(com.sun.source.tree.Tree, com.sun.source.tree.ExpressionTree, java.lang.String, java.lang.Object...), which ultimately calls the TypeHierarchy.isSubtype(org.checkerframework.framework.type.AnnotatedTypeMirror, org.checkerframework.framework.type.AnnotatedTypeMirror) method and reports errors that violate Java's rules of assignment.
Note that since this implementation only performs assignment and pseudo-assignment checking, other rules for custom type systems must be added in subclasses (e.g., dereference checking in the NullnessChecker is implemented in the NullnessChecker's TreeScanner.visitMemberSelect(com.sun.source.tree.MemberSelectTree, P) method).
This implementation does the following checks:
1. Assignment and Pseudo-Assignment Check: It verifies that any assignment type-checks, using TypeHierarchy.isSubtype method. This includes method invocation and method overriding checks.
2. Type Validity Check: It verifies that any user-supplied type is a valid type, using isValidUse method.
3. (Re-)Assignability Check: It verifies that any assignment is valid, using Checker.isAssignable method.
See Also:

"JLS $4", TypeHierarchy.isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror), AnnotatedTypeFactory

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class BaseTypeVisitor.OverrideChecker
Class to perform method override and method reference checks.

Nested Classes
Modifier and Type	Class and Description
`class`	`BaseTypeVisitor.OverrideChecker` Class to perform method override and method reference checks.

Field Summary

Fields
Modifier and Type	Field and Description
`protected Factory`	`atypeFactory` The factory to use for obtaining "parsed" version of annotations.
`protected BaseTypeChecker`	`checker` The `BaseTypeChecker` for error reporting.
`protected ContractsUtils`	`contractsUtils` An instance of the `ContractsUtils` helper class.
`protected SourcePositions`	`positions` For obtaining line numbers in -Ashowchecks debugging output.
`protected AnnotationMirror`	`TARGET` The @java.lang.annotation.Target annotation.
`protected ExecutableElement`	`targetValueElement` The `value` element/field of the @java.lang.annotation.Target annotation.
`protected TypeValidator`	`typeValidator`
`protected VisitorState`	`visitorState` For storing visitor state.

Fields inherited from class org.checkerframework.framework.source.SourceVisitor
elements, root, trees, treesWithSuppressWarnings, types

Constructor Summary

Constructors
Modifier Constructor and Description

BaseTypeVisitor(BaseTypeChecker checker)

protected BaseTypeVisitor(BaseTypeChecker checker, Factory typeFactory)

Constructors
Modifier	Constructor and Description
	`BaseTypeVisitor(BaseTypeChecker checker)`
`protected`	`BaseTypeVisitor(BaseTypeChecker checker, Factory typeFactory)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`checkAccess(IdentifierTree node, Void p)`
`protected void`	`checkArguments(List<? extends AnnotatedTypeMirror> requiredArgs, List<? extends ExpressionTree> passedArgs, Name executableName, List<?> paramNames)` A helper method to check that each passed argument is a subtype of the corresponding required argument, and issues "argument.invalid" error for each passed argument that not a subtype of the required one.
`protected void`	`checkArrayInitialization(AnnotatedTypeMirror type, List<? extends ExpressionTree> initializers)`
`protected void`	`checkConditionalPostcondition(MethodTree method, AnnotationMirror annotation, AnnotationMirror contractAnnotation, FlowExpressions.Receiver expression, boolean result)` Check that the expression's type is annotated with `annotation` at every regular exit that returns `result`.
`protected void`	`checkConstructorInvocation(AnnotatedTypeMirror.AnnotatedDeclaredType invocation, AnnotatedTypeMirror.AnnotatedExecutableType constructor, NewClassTree newClassTree)` Check that the (explicit) annotations on a new class tree are comparable to the result type of the constructor.
`protected void`	`checkConstructorResult(AnnotatedTypeMirror.AnnotatedExecutableType constructorType, ExecutableElement constructorElement)` Issue a warning if the result type of the constructor is not top.
`protected boolean`	`checkContract(FlowExpressions.Receiver expr, AnnotationMirror necessaryAnnotation, AnnotationMirror inferredAnnotation, CFAbstractStore<?,?> store)` Returns true if and only if `inferredAnnotation` is valid for a given expression to match the `necessaryAnnotation`.
`protected void`	`checkDefaultConstructor(ClassTree node)`
`protected void`	`checkExceptionParameter(CatchTree node)` Issue error if the exception parameter is not a supertype of the annotation specified by `getExceptionParameterLowerBoundAnnotations()`, which is top by default.
`protected void`	`checkExtendsImplements(ClassTree classTree)` If "@B class Y extends @A X {}", then enforce that @B must be a subtype of @A.
`protected void`	`checkFieldInvariantDeclarations(ClassTree classTree)` Check that the field invariant declaration annotations meet the following requirements: If the superclass of `classTree` has a field invariant, then the field invariant for `classTree` must include all the fields in the superclass invariant and those fields' annotations must be a subtype (or equal) to the annotations for those fields in the superclass.
`protected void`	`checkMethodInvocability(AnnotatedTypeMirror.AnnotatedExecutableType method, MethodInvocationTree node)` Tests whether the method can be invoked using the receiver of the 'node' method invocation, and issues a "method.invocation.invalid" if the invocation is invalid.
`protected boolean`	`checkMethodReferenceAsOverride(MemberReferenceTree memberReferenceTree, Void p)` Check that a method reference is allowed.
`protected boolean`	`checkOverride(MethodTree overriderTree, AnnotatedTypeMirror.AnnotatedDeclaredType overridingType, AnnotatedTypeMirror.AnnotatedExecutableType overridden, AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType)` Type checks that a method may override another method.
`protected boolean`	`checkOverride(MethodTree overriderTree, AnnotatedTypeMirror.AnnotatedExecutableType overrider, AnnotatedTypeMirror.AnnotatedDeclaredType overridingType, AnnotatedTypeMirror.AnnotatedExecutableType overridden, AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType)` Type checks that a method may override another method.
`protected void`	`checkPostcondition(MethodTree methodTree, AnnotationMirror annotation, AnnotationMirror contractAnnotation, FlowExpressions.Receiver expression)` Check that the expression's type is annotated with `annotation` at the regular exit store.
`protected void`	`checkPreconditions(MethodInvocationTree tree, Set<Contract.Precondition> preconditions)` Checks that all the given `preconditions` hold true immediately prior to the method invocation or variable access at `tree`.
`protected void`	`checkPurity(MethodTree node)` Check method purity if needed.
`protected void`	`checkQualifierParameter(ClassTree classTree)` Issues an error if `classTree` has polymorphic fields but is not annotated with `@HasQualifierParameter`.
`protected void`	`checkSuperConstructorCall(MethodInvocationTree superCall)` Checks that the following rule is satisfied: The type on a constructor declaration must be a supertype of the return type of "super()" invocation within that constructor.
`protected void`	`checkThisConstructorCall(MethodInvocationTree thisCall)` Checks that the following rule is satisfied: The type on a constructor declaration must be a supertype of the return type of "this()" invocation within that constructor.
`protected void`	`checkThisOrSuperConstructorCall(MethodInvocationTree call, @CompilerMessageKey String errorKey)` Checks that the following rule is satisfied: The type on a constructor declaration must be a supertype of the return type of "this()" or "super()" invocation within that constructor.
`protected void`	`checkThrownExpression(ThrowTree node)` Checks the type of the thrown expression.
`protected void`	`checkTypeArguments(Tree toptree, List<? extends AnnotatedTypeParameterBounds> paramBounds, List<? extends AnnotatedTypeMirror> typeargs, List<? extends Tree> typeargTrees, Name typeOrMethodName, List<?> paramNames)` 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.
`protected void`	`checkTypecastRedundancy(TypeCastTree typeCastTree)` If the lint option "cast:redundant" is set, this methods issues a warning if the cast is redundant.
`protected void`	`checkTypecastSafety(TypeCastTree typeCastTree)` Issues a warning if the given explicitly-written typecast is unsafe.
`protected void`	`checkVarargs(AnnotatedTypeMirror.AnnotatedExecutableType invokedMethod, Tree tree)` A helper method to check that the array type of actual varargs is a subtype of the corresponding required varargs, and issues "argument.invalid" error if it's not a subtype of the required one.
`protected void`	`commonAssignmentCheck(AnnotatedTypeMirror varType, AnnotatedTypeMirror valueType, Tree valueTree, @CompilerMessageKey String errorKey, Object... extraArgs)` Checks the validity of an assignment (or pseudo-assignment) from a value to a variable and emits an error message (through the compiler's messaging interface) if it is not valid.
`protected void`	`commonAssignmentCheck(AnnotatedTypeMirror varType, ExpressionTree valueExp, @CompilerMessageKey String errorKey, Object... extraArgs)` Checks the validity of an assignment (or pseudo-assignment) from a value to a variable and emits an error message (through the compiler's messaging interface) if it is not valid.
`protected void`	`commonAssignmentCheck(Tree varTree, ExpressionTree valueExp, @CompilerMessageKey String errorKey, Object... extraArgs)` Checks the validity of an assignment (or pseudo-assignment) from a value to a variable and emits an error message (through the compiler's messaging interface) if it is not valid.
`protected void`	`commonAssignmentCheckEndDiagnostic(boolean success, String extraMessage, AnnotatedTypeMirror varType, AnnotatedTypeMirror valueType, Tree valueTree)` Prints a diagnostic about exiting commonAssignmentCheck, if the showchecks option was set.
`protected void`	`commonAssignmentCheckEndDiagnostic(String message, AnnotatedTypeMirror varType, AnnotatedTypeMirror valueType, Tree valueTree)` Prints a diagnostic about exiting commonAssignmentCheck, if the showchecks option was set.
`protected void`	`commonAssignmentCheckStartDiagnostic(AnnotatedTypeMirror varType, AnnotatedTypeMirror valueType, Tree valueTree)` Prints a diagnostic about entering commonAssignmentCheck, if the showchecks option was set.
`protected BaseTypeVisitor.OverrideChecker`	`createOverrideChecker(Tree overriderTree, AnnotatedTypeMirror.AnnotatedExecutableType overrider, AnnotatedTypeMirror overridingType, AnnotatedTypeMirror overridingReturnType, AnnotatedTypeMirror.AnnotatedExecutableType overridden, AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType, AnnotatedTypeMirror overriddenReturnType)` Create an OverrideChecker.
`protected Factory`	`createTypeFactory()` Constructs an instance of the appropriate type factory for the implemented type system.
`protected TypeValidator`	`createTypeValidator()`
`protected MemberSelectTree`	`enclosingMemberSelect()` Call this only when the current path is an identifier.
`protected Tree`	`enclosingStatement(Tree tree)` Returns the statement that encloses the given one.
`protected Set<? extends AnnotationMirror>`	`getExceptionParameterLowerBoundAnnotations()` Returns a set of AnnotationMirrors that is a lower bound for exception parameters.
`protected Set<? extends AnnotationMirror>`	`getThrowUpperBoundAnnotations()` Returns a set of AnnotationMirrors that is a upper bound for thrown exceptions.
`Factory`	`getTypeFactory()`
`protected boolean`	`isAccessAllowed(Element field, AnnotatedTypeMirror receiver, ExpressionTree accessTree)` Returns true if access is allowed, based on an @Unused annotation
`protected boolean`	`isTypeCastSafe(AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType)` Returns true if the cast is safe.
`boolean`	`isValidUse(AnnotatedTypeMirror.AnnotatedArrayType type, Tree tree)` Tests that the qualifiers present on the array type are valid.
`boolean`	`isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType, AnnotatedTypeMirror.AnnotatedDeclaredType useType, Tree tree)` Tests that the qualifiers present on the useType are valid qualifiers, given the qualifiers on the declaration of the type, declarationType.
`boolean`	`isValidUse(AnnotatedTypeMirror.AnnotatedPrimitiveType type, Tree tree)` Tests that the qualifiers present on the primitive type are valid.
`void`	`processClassTree(ClassTree classTree)` Type-check classTree.
`protected void`	`reportMethodInvocabilityError(MethodInvocationTree node, AnnotatedTypeMirror found, AnnotatedTypeMirror expected)` Report a method invocability error.
`protected void`	`reportPurityErrors(PurityChecker.PurityResult result, MethodTree node, EnumSet<Pure.Kind> expectedKinds)` Reports errors found during purity checking.
`Void`	`scan(@Nullable Tree tree, Void p)`
`void`	`setRoot(CompilationUnitTree root)` Set the CompilationUnitTree to be used during any visits.
`protected boolean`	`shouldSkipUses(ExpressionTree exprTree)` Tests whether the expression should not be checked because of the tree referring to unannotated classes, as specified in the `checker.skipUses` property.
`protected boolean`	`skipReceiverSubtypeCheck(MethodInvocationTree node, AnnotatedTypeMirror methodDefinitionReceiver, AnnotatedTypeMirror methodCallReceiver)` Indicates whether to skip subtype checks on the receiver when checking method invocability.
`protected boolean`	`testTypevarContainment(AnnotatedTypeMirror inner, AnnotatedTypeMirror outer)` Returns true if both types are type variables and outer contains inner.
`protected void`	`typeCheckVectorCopyIntoArgument(MethodInvocationTree node, List<? extends AnnotatedTypeMirror> params)` Type checks the method arguments of `Vector.copyInto()`.
`protected boolean`	`validateType(Tree tree, AnnotatedTypeMirror type)` Tests whether the type and corresponding type tree is a valid type, and emits an error if that is not the case (e.g.
`boolean`	`validateTypeOf(Tree tree)` Tests whether the tree expressed by the passed type tree is a valid type, and emits an error if that is not the case (e.g.
`Void`	`visitAnnotation(AnnotationTree node, Void p)` Ensure that the annotation arguments comply to their declarations.
`Void`	`visitArrayAccess(ArrayAccessTree node, Void p)`
`Void`	`visitAssignment(AssignmentTree node, Void p)` Performs two checks: subtyping and assignability checks, using `commonAssignmentCheck(Tree, ExpressionTree, String, Object[])`.
`Void`	`visitCatch(CatchTree node, Void p)` Checks the type of the exception parameter Subclasses should override checkExceptionParameter(CatchTree node) rather than this method to change the behavior of this check.
`Void`	`visitClass(ClassTree classTree, Void p)` Type-check classTree and skips classes specified by the skipDef option.
`Void`	`visitCompilationUnit(CompilationUnitTree node, Void p)` Override Compilation Unit so we won't visit package names or imports.
`Void`	`visitCompoundAssignment(CompoundAssignmentTree node, Void p)` Performs assignability check.
`Void`	`visitConditionalExpression(ConditionalExpressionTree node, Void p)` If the computation of the type of the ConditionalExpressionTree in org.checkerframework.framework.type.TypeFromTree.TypeFromExpression.visitConditionalExpression(ConditionalExpressionTree, AnnotatedTypeFactory) is correct, the following checks are redundant.
`Void`	`visitEnhancedForLoop(EnhancedForLoopTree node, Void p)` Performs a subtype check, to test whether the node expression iterable type is a subtype of the variable type in the enhanced for loop.
`Void`	`visitIdentifier(IdentifierTree node, Void p)`
`Void`	`visitInstanceOf(InstanceOfTree node, Void p)`
`Void`	`visitLambdaExpression(LambdaExpressionTree node, Void p)`
`Void`	`visitMemberReference(MemberReferenceTree node, Void p)`
`Void`	`visitMethod(MethodTree node, Void p)` Performs pseudo-assignment check: checks that the method obeys override and subtype rules to all overridden methods.
`Void`	`visitMethodInvocation(MethodInvocationTree node, Void p)` Performs a method invocation check.
`Void`	`visitNewArray(NewArrayTree node, Void p)`
`Void`	`visitNewClass(NewClassTree node, Void p)` Performs a new class invocation check.
`Void`	`visitReturn(ReturnTree node, Void p)` Checks that the type of the return expression is a subtype of the enclosing method required return type.
`Void`	`visitThrow(ThrowTree node, Void p)` Checks the type of a thrown exception.
`Void`	`visitTypeCast(TypeCastTree node, Void p)`
`Void`	`visitTypeParameter(TypeParameterTree node, Void p)`
`Void`	`visitUnary(UnaryTree node, Void p)` Performs assignability check.
`Void`	`visitVariable(VariableTree node, Void p)`

Methods inherited from class org.checkerframework.framework.source.SourceVisitor
visit

Methods inherited from class com.sun.source.util.TreePathScanner
getCurrentPath, scan

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - checker
```
protected final BaseTypeChecker checker
```
    The BaseTypeChecker for error reporting.
  - atypeFactory
```
protected final Factory extends GenericAnnotatedTypeFactory<?,?,?,?> atypeFactory
```
    The factory to use for obtaining "parsed" version of annotations.
  - positions
```
protected final SourcePositions positions
```
    For obtaining line numbers in -Ashowchecks debugging output.
  - visitorState
```
protected final VisitorState visitorState
```
    For storing visitor state.
  - contractsUtils
```
protected final ContractsUtils contractsUtils
```
    An instance of the ContractsUtils helper class.
  - TARGET
```
protected final AnnotationMirror TARGET
```
    The @java.lang.annotation.Target annotation.
  - targetValueElement
```
protected final ExecutableElement targetValueElement
```
    The value element/field of the @java.lang.annotation.Target annotation.
  - typeValidator
```
protected final TypeValidator typeValidator
```
- Constructor Detail
  - BaseTypeVisitor
```
public BaseTypeVisitor(BaseTypeChecker checker)
```
    Parameters:
    
    checker - the type-checker associated with this visitor (for callbacks to TypeHierarchy.isSubtype(org.checkerframework.framework.type.AnnotatedTypeMirror, org.checkerframework.framework.type.AnnotatedTypeMirror))
  - BaseTypeVisitor
```
protected BaseTypeVisitor(BaseTypeChecker checker,
                          Factory typeFactory)
```
    Parameters:
    
    checker - the type-checker associated with this visitor
    
    typeFactory - the type factory, or null. If null, this calls createTypeFactory().
- Method Detail
  - createTypeFactory
```
protected Factory createTypeFactory()
```
    Constructs an instance of the appropriate type factory for the implemented type system.
    The default implementation uses the checker naming convention to create the appropriate type factory. If no factory is found, it returns BaseAnnotatedTypeFactory. It reflectively invokes the constructor that accepts this checker and compilation unit tree (in that order) as arguments.
    Subclasses have to override this method to create the appropriate visitor if they do not follow the checker naming convention.
    
    Returns:
    
    the appropriate type factory
  - getTypeFactory
```
public final Factory getTypeFactory()
```
  - setRoot
```
public void setRoot(CompilationUnitTree root)
```
    Description copied from class: SourceVisitor
    
    Set the CompilationUnitTree to be used during any visits. For any later calls of com.sun.source.util.TreePathScanner.scan(TreePath, P), the CompilationUnitTree of the TreePath has to be equal to root.
    
    Overrides:
    
    setRoot in class SourceVisitor<Void,Void>
  - scan
```
public Void scan(@Nullable Tree tree,
                 Void p)
```
    Overrides:
    
    scan in class SourceVisitor<Void,Void>
  - visitClass
```
public final Void visitClass(ClassTree classTree,
                             Void p)
```
    Type-check classTree and skips classes specified by the skipDef option. Subclasses should override processClassTree(ClassTree) instead of this method.
    
    Specified by:
    
    visitClass in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitClass in class SourceVisitor<Void,Void>
    
    Parameters:
    
    classTree - class to check
    
    p - null
    
    Returns:
    
    null
  - processClassTree
```
public void processClassTree(ClassTree classTree)
```
    Type-check classTree. Subclasses should override this method instead of visitClass(ClassTree, Void).
    
    Parameters:
    
    classTree - class to check
  - checkQualifierParameter
```
protected void checkQualifierParameter(ClassTree classTree)
```
    Issues an error if classTree has polymorphic fields but is not annotated with @HasQualifierParameter. Always issue a warning if the type of a static field is annotated with a polymorphic qualifier.
    Issues an error if classTree extends or implements a class/interface that has a qualifier parameter, but this class does not.
    
    Parameters:
    
    classTree - the ClassTree to check for polymorphic fields
  - checkExtendsImplements
```
protected void checkExtendsImplements(ClassTree classTree)
```
    If "@B class Y extends @A X {}", then enforce that @B must be a subtype of @A.
    Also validate the types of the extends and implements clauses.
    
    Parameters:
    
    classTree - class tree to check
  - checkFieldInvariantDeclarations
```
protected void checkFieldInvariantDeclarations(ClassTree classTree)
```
    Check that the field invariant declaration annotations meet the following requirements:
    1. If the superclass of classTree has a field invariant, then the field invariant for classTree must include all the fields in the superclass invariant and those fields' annotations must be a subtype (or equal) to the annotations for those fields in the superclass.
    2. The fields in the invariant must be a.) final and b.) declared in a superclass of classTree.
    3. The qualifier for each field must be a subtype of the annotation on the declaration of that field.
    4. The field invariant has an equal number of fields and qualifiers, or it has one qualifier and at least one field.
    Parameters:
    
    classTree - class that might have a field invariant
    
    See the Checker Framework Manual:
    Field invariants
  - checkDefaultConstructor
```
protected void checkDefaultConstructor(ClassTree node)
```
  - visitMethod
```
public Void visitMethod(MethodTree node,
                        Void p)
```
    Performs pseudo-assignment check: checks that the method obeys override and subtype rules to all overridden methods.
    The override rule specifies that a method, m1, may override a method m2 only if:
    - m1 return type is a subtype of m2
    - m1 receiver type is a supertype of m2
    - m1 parameters are supertypes of corresponding m2 parameters
    Also, it issues a "missing.this" error for static method annotated receivers.
    Specified by:
    
    visitMethod in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitMethod in class SourceVisitor<Void,Void>
  - checkPurity
```
protected void checkPurity(MethodTree node)
```
    Check method purity if needed. Note that overriding rules are checked as part of checkOverride(MethodTree, AnnotatedTypeMirror.AnnotatedExecutableType, AnnotatedTypeMirror.AnnotatedDeclaredType, AnnotatedTypeMirror.AnnotatedExecutableType, AnnotatedTypeMirror.AnnotatedDeclaredType).
    
    Parameters:
    
    node - the method tree to check
  - checkConstructorResult
```
protected void checkConstructorResult(AnnotatedTypeMirror.AnnotatedExecutableType constructorType,
                                      ExecutableElement constructorElement)
```
    Issue a warning if the result type of the constructor is not top. If it is a supertype of the class, then a type.invalid.conflicting.annos error will also be issued by isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedDeclaredType,Tree).
    
    Parameters:
    
    constructorType - AnnotatedExecutableType for the constructor
    
    constructorElement - element that declares the constructor
  - reportPurityErrors
```
protected void reportPurityErrors(PurityChecker.PurityResult result,
                                  MethodTree node,
                                  EnumSet<Pure.Kind> expectedKinds)
```
    Reports errors found during purity checking.
    
    Parameters:
    
    result - whether the method is deterministic and/or side-effect-free
    
    node - the method
    
    expectedKinds - the expected purity for the method
  - checkPostcondition
```
protected void checkPostcondition(MethodTree methodTree,
                                  AnnotationMirror annotation,
                                  AnnotationMirror contractAnnotation,
                                  FlowExpressions.Receiver expression)
```
    Check that the expression's type is annotated with annotation at the regular exit store.
    
    Parameters:
    
    methodTree - declaration of the method
    
    annotation - expression's type must have this annotation
    
    contractAnnotation - the user-written postcondition annotation, which mentions expression. Used only for diagnostic messages.
    
    expression - the expression that the postcondition contractAnnotation concerns
  - checkConditionalPostcondition
```
protected void checkConditionalPostcondition(MethodTree method,
                                             AnnotationMirror annotation,
                                             AnnotationMirror contractAnnotation,
                                             FlowExpressions.Receiver expression,
                                             boolean result)
```
    Check that the expression's type is annotated with annotation at every regular exit that returns result.
    
    Parameters:
    
    method - tree of method with the postcondition
    
    annotation - expression's type must have this annotation
    
    contractAnnotation - the user-written postcondition annotation, which mentions expression. Used only for diagnostic messages.
    
    expression - the expression that the postcondition concerns
    
    result - result for which the postcondition is valid
  - visitTypeParameter
```
public Void visitTypeParameter(TypeParameterTree node,
                               Void p)
```
    Specified by:
    
    visitTypeParameter in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitTypeParameter in class TreeScanner<Void,Void>
  - visitVariable
```
public Void visitVariable(VariableTree node,
                          Void p)
```
    Specified by:
    
    visitVariable in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitVariable in class SourceVisitor<Void,Void>
  - visitAssignment
```
public Void visitAssignment(AssignmentTree node,
                            Void p)
```
    Performs two checks: subtyping and assignability checks, using commonAssignmentCheck(Tree, ExpressionTree, String, Object[]).
    If the subtype check fails, it issues a "assignment.type.incompatible" error.
    
    Specified by:
    
    visitAssignment in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitAssignment in class TreeScanner<Void,Void>
  - visitEnhancedForLoop
```
public Void visitEnhancedForLoop(EnhancedForLoopTree node,
                                 Void p)
```
    Performs a subtype check, to test whether the node expression iterable type is a subtype of the variable type in the enhanced for loop.
    If the subtype check fails, it issues a "enhancedfor.type.incompatible" error.
    
    Specified by:
    
    visitEnhancedForLoop in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitEnhancedForLoop in class TreeScanner<Void,Void>
  - visitMethodInvocation
```
public Void visitMethodInvocation(MethodInvocationTree node,
                                  Void p)
```
    Performs a method invocation check.
    An invocation of a method, m, on the receiver, r is valid only if:
    - passed arguments are subtypes of corresponding m parameters
    - r is a subtype of m receiver type
    - if m is generic, passed type arguments are subtypes of m type variables
    Specified by:
    
    visitMethodInvocation in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitMethodInvocation in class TreeScanner<Void,Void>
  - checkThisConstructorCall
```
protected void checkThisConstructorCall(MethodInvocationTree thisCall)
```
    Checks that the following rule is satisfied: The type on a constructor declaration must be a supertype of the return type of "this()" invocation within that constructor.
    Subclasses can override this method to change the behavior for just "this" constructor class. Or override checkThisOrSuperConstructorCall(MethodInvocationTree, String) to change the behavior for "this" and "super" constructor calls.
    
    Parameters:
    
    thisCall - the AST node for the constructor call
  - checkSuperConstructorCall
```
protected void checkSuperConstructorCall(MethodInvocationTree superCall)
```
    Checks that the following rule is satisfied: The type on a constructor declaration must be a supertype of the return type of "super()" invocation within that constructor.
    Subclasses can override this method to change the behavior for just "super" constructor class. Or override checkThisOrSuperConstructorCall(MethodInvocationTree, String) to change the behavior for "this" and "super" constructor calls.
    
    Parameters:
    
    superCall - the AST node for the super constructor call
  - checkThisOrSuperConstructorCall
```
protected void checkThisOrSuperConstructorCall(MethodInvocationTree call,
                                               @CompilerMessageKey String errorKey)
```
    Checks that the following rule is satisfied: The type on a constructor declaration must be a supertype of the return type of "this()" or "super()" invocation within that constructor.
    
    Parameters:
    
    call - the AST node for the constructor call
    
    errorKey - the error message key to use if the check fails
  - checkVarargs
```
protected void checkVarargs(AnnotatedTypeMirror.AnnotatedExecutableType invokedMethod,
                            Tree tree)
```
    A helper method to check that the array type of actual varargs is a subtype of the corresponding required varargs, and issues "argument.invalid" error if it's not a subtype of the required one.
    Note it's required that type checking for each element in varargs is executed by the caller before or after calling this method.
    
    Parameters:
    
    invokedMethod - the method type to be invoked
    
    tree - method or constructor invocation tree
    
    See Also:
    
    checkArguments(java.util.List<? extends org.checkerframework.framework.type.AnnotatedTypeMirror>, java.util.List<? extends com.sun.source.tree.ExpressionTree>, javax.lang.model.element.Name, java.util.List<?>)
  - checkPreconditions
```
protected void checkPreconditions(MethodInvocationTree tree,
                                  Set<Contract.Precondition> preconditions)
```
    Checks that all the given preconditions hold true immediately prior to the method invocation or variable access at tree.
    
    Parameters:
    
    tree - the Tree immediately prior to which the preconditions must hold true
    
    preconditions - the preconditions to be checked
  - checkContract
```
protected boolean checkContract(FlowExpressions.Receiver expr,
                                AnnotationMirror necessaryAnnotation,
                                AnnotationMirror inferredAnnotation,
                                CFAbstractStore<?,?> store)
```
    Returns true if and only if inferredAnnotation is valid for a given expression to match the necessaryAnnotation.
    By default, inferredAnnotation must be a subtype of necessaryAnnotation, but subclasses might override this behavior.
  - typeCheckVectorCopyIntoArgument
```
protected void typeCheckVectorCopyIntoArgument(MethodInvocationTree node,
                                               List<? extends AnnotatedTypeMirror> params)
```
    Type checks the method arguments of Vector.copyInto().
    The Checker Framework special-cases the method invocation, as its type safety cannot be expressed by Java's type system.
    For a Vector v of type Vector<E>, the method invocation v.copyInto(arr) is type-safe iff arr is an array of type T[], where T is a subtype of E.
    In other words, this method checks that the type argument of the receiver method is a subtype of the component type of the passed array argument.
    
    Parameters:
    
    node - a method invocation of Vector.copyInto()
    
    params - the types of the parameters of Vectory.copyInto()
  - visitNewClass
```
public Void visitNewClass(NewClassTree node,
                          Void p)
```
    Performs a new class invocation check.
    An invocation of a constructor, c, is valid only if:
    - passed arguments are subtypes of corresponding c parameters
    - if c is generic, passed type arguments are subtypes of c type variables
    Specified by:
    
    visitNewClass in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitNewClass in class TreeScanner<Void,Void>
  - visitLambdaExpression
```
public Void visitLambdaExpression(LambdaExpressionTree node,
                                  Void p)
```
    Specified by:
    
    visitLambdaExpression in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitLambdaExpression in class TreeScanner<Void,Void>
  - visitMemberReference
```
public Void visitMemberReference(MemberReferenceTree node,
                                 Void p)
```
    Specified by:
    
    visitMemberReference in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitMemberReference in class TreeScanner<Void,Void>
  - visitReturn
```
public Void visitReturn(ReturnTree node,
                        Void p)
```
    Checks that the type of the return expression is a subtype of the enclosing method required return type. If not, it issues a "return.type.incompatible" error.
    
    Specified by:
    
    visitReturn in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitReturn in class TreeScanner<Void,Void>
  - visitAnnotation
```
public Void visitAnnotation(AnnotationTree node,
                            Void p)
```
    Ensure that the annotation arguments comply to their declarations. This needs some special casing, as annotation arguments form special trees.
    
    Specified by:
    
    visitAnnotation in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitAnnotation in class TreeScanner<Void,Void>
  - visitConditionalExpression
```
public Void visitConditionalExpression(ConditionalExpressionTree node,
                                       Void p)
```
    If the computation of the type of the ConditionalExpressionTree in org.checkerframework.framework.type.TypeFromTree.TypeFromExpression.visitConditionalExpression(ConditionalExpressionTree, AnnotatedTypeFactory) is correct, the following checks are redundant. However, let's add another failsafe guard and do the checks.
    
    Specified by:
    
    visitConditionalExpression in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitConditionalExpression in class TreeScanner<Void,Void>
  - visitUnary
```
public Void visitUnary(UnaryTree node,
                       Void p)
```
    Performs assignability check.
    
    Specified by:
    
    visitUnary in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitUnary in class TreeScanner<Void,Void>
  - visitCompoundAssignment
```
public Void visitCompoundAssignment(CompoundAssignmentTree node,
                                    Void p)
```
    Performs assignability check.
    
    Specified by:
    
    visitCompoundAssignment in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitCompoundAssignment in class TreeScanner<Void,Void>
  - visitNewArray
```
public Void visitNewArray(NewArrayTree node,
                          Void p)
```
    Specified by:
    
    visitNewArray in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitNewArray in class TreeScanner<Void,Void>
  - checkTypecastRedundancy
```
protected void checkTypecastRedundancy(TypeCastTree typeCastTree)
```
    If the lint option "cast:redundant" is set, this methods issues a warning if the cast is redundant.
  - checkTypecastSafety
```
protected void checkTypecastSafety(TypeCastTree typeCastTree)
```
    Issues a warning if the given explicitly-written typecast is unsafe. Does nothing if the lint option "cast:unsafe" is not set. Only primary qualifiers are checked unless the command line option "checkCastElementType" is supplied.
    
    Parameters:
    
    typeCastTree - an explicitly-written typecast
  - isTypeCastSafe
```
protected boolean isTypeCastSafe(AnnotatedTypeMirror castType,
                                 AnnotatedTypeMirror exprType)
```
    Returns true if the cast is safe.
    Only primary qualifiers are checked unless the command line option "checkCastElementType" is supplied.
    
    Parameters:
    
    castType - annotated type of the cast
    
    exprType - annotated type of the casted expression
    
    Returns:
    
    true if the type cast is safe, false otherwise
  - visitTypeCast
```
public Void visitTypeCast(TypeCastTree node,
                          Void p)
```
    Specified by:
    
    visitTypeCast in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitTypeCast in class TreeScanner<Void,Void>
  - visitInstanceOf
```
public Void visitInstanceOf(InstanceOfTree node,
                            Void p)
```
    Specified by:
    
    visitInstanceOf in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitInstanceOf in class TreeScanner<Void,Void>
  - visitArrayAccess
```
public Void visitArrayAccess(ArrayAccessTree node,
                             Void p)
```
    Specified by:
    
    visitArrayAccess in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitArrayAccess in class TreeScanner<Void,Void>
  - visitCatch
```
public Void visitCatch(CatchTree node,
                       Void p)
```
    Checks the type of the exception parameter Subclasses should override checkExceptionParameter(CatchTree node) rather than this method to change the behavior of this check.
    
    Specified by:
    
    visitCatch in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitCatch in class TreeScanner<Void,Void>
  - visitThrow
```
public Void visitThrow(ThrowTree node,
                       Void p)
```
    Checks the type of a thrown exception. Subclasses should override checkThrownExpression(ThrowTree node) rather than this method to change the behavior of this check.
    
    Specified by:
    
    visitThrow in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitThrow in class TreeScanner<Void,Void>
  - checkExceptionParameter
```
protected void checkExceptionParameter(CatchTree node)
```
    Issue error if the exception parameter is not a supertype of the annotation specified by getExceptionParameterLowerBoundAnnotations(), which is top by default.
    Subclasses may override this method to change the behavior of this check. Subclasses wishing to enforce that exception parameter be annotated with other annotations can just override getExceptionParameterLowerBoundAnnotations().
    
    Parameters:
    
    node - CatchTree to check
  - getExceptionParameterLowerBoundAnnotations
```
protected Set<? extends AnnotationMirror> getExceptionParameterLowerBoundAnnotations()
```
    Returns a set of AnnotationMirrors that is a lower bound for exception parameters.
    Note: by default this method is called by getThrowUpperBoundAnnotations(), so that this annotation is enforced.
    (Default is top)
    
    Returns:
    
    set of annotation mirrors, one per hierarchy, that from a lower bound of annotations that can be written on an exception parameter
  - checkThrownExpression
```
protected void checkThrownExpression(ThrowTree node)
```
    Checks the type of the thrown expression.
    By default, this method checks that the thrown expression is a subtype of top.
    Issue error if the thrown expression is not a sub type of the annotation given by getThrowUpperBoundAnnotations(), the same as getExceptionParameterLowerBoundAnnotations() by default.
    Subclasses may override this method to change the behavior of this check. Subclasses wishing to enforce that the thrown expression be a subtype of a type besides getExceptionParameterLowerBoundAnnotations(), should override getThrowUpperBoundAnnotations().
    
    Parameters:
    
    node - ThrowTree to check
  - getThrowUpperBoundAnnotations
```
protected Set<? extends AnnotationMirror> getThrowUpperBoundAnnotations()
```
    Returns a set of AnnotationMirrors that is a upper bound for thrown exceptions.
    Note: by default this method is returns by getExceptionParameterLowerBoundAnnotations(), so that this annotation is enforced.
    (Default is top)
    
    Returns:
    
    set of annotation mirrors, one per hierarchy, that form an upper bound of thrown expressions
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(Tree varTree,
                                     ExpressionTree valueExp,
                                     @CompilerMessageKey String errorKey,
                                     Object... extraArgs)
```
    Checks the validity of an assignment (or pseudo-assignment) from a value to a variable and emits an error message (through the compiler's messaging interface) if it is not valid.
    
    Parameters:
    
    varTree - the AST node for the lvalue (usually a variable)
    
    valueExp - the AST node for the rvalue (the new value)
    
    errorKey - the error message key to use if the check fails
    
    extraArgs - arguments to the error message key, before "found" and "expected" types
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(AnnotatedTypeMirror varType,
                                     ExpressionTree valueExp,
                                     @CompilerMessageKey String errorKey,
                                     Object... extraArgs)
```
    Checks the validity of an assignment (or pseudo-assignment) from a value to a variable and emits an error message (through the compiler's messaging interface) if it is not valid.
    
    Parameters:
    
    varType - the annotated type for the lvalue (usually a variable)
    
    valueExp - the AST node for the rvalue (the new value)
    
    errorKey - the error message key to use if the check fails
    
    extraArgs - arguments to the error message key, before "found" and "expected" types
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(AnnotatedTypeMirror varType,
                                     AnnotatedTypeMirror valueType,
                                     Tree valueTree,
                                     @CompilerMessageKey String errorKey,
                                     Object... extraArgs)
```
    Checks the validity of an assignment (or pseudo-assignment) from a value to a variable and emits an error message (through the compiler's messaging interface) if it is not valid.
    
    Parameters:
    
    varType - the annotated type of the variable
    
    valueType - the annotated type of the value
    
    valueTree - the location to use when reporting the error message
    
    errorKey - the error message key to use if the check fails
    
    extraArgs - arguments to the error message key, before "found" and "expected" types
  - commonAssignmentCheckStartDiagnostic
```
protected final void commonAssignmentCheckStartDiagnostic(AnnotatedTypeMirror varType,
                                                          AnnotatedTypeMirror valueType,
                                                          Tree valueTree)
```
    Prints a diagnostic about entering commonAssignmentCheck, if the showchecks option was set.
    
    Parameters:
    
    varType - the annotated type of the variable
    
    valueType - the annotated type of the value
    
    valueTree - the location to use when reporting the error message
  - commonAssignmentCheckEndDiagnostic
```
protected final void commonAssignmentCheckEndDiagnostic(boolean success,
                                                        String extraMessage,
                                                        AnnotatedTypeMirror varType,
                                                        AnnotatedTypeMirror valueType,
                                                        Tree valueTree)
```
    Prints a diagnostic about exiting commonAssignmentCheck, if the showchecks option was set.
    
    Parameters:
    
    success - whether the check succeeded or failed
    
    extraMessage - information about why the result is what it is; may be null
    
    varType - the annotated type of the variable
    
    valueType - the annotated type of the value
    
    valueTree - the location to use when reporting the error message
  - commonAssignmentCheckEndDiagnostic
```
protected final void commonAssignmentCheckEndDiagnostic(String message,
                                                        AnnotatedTypeMirror varType,
                                                        AnnotatedTypeMirror valueType,
                                                        Tree valueTree)
```
    Prints a diagnostic about exiting commonAssignmentCheck, if the showchecks option was set.
    Most clients should call commonAssignmentCheckEndDiagnostic(boolean, String, AnnotatedTypeMirror, AnnotatedTypeMirror, Tree). The purpose of this method is to permit customizing the message that is printed.
    
    Parameters:
    
    message - the result, plus information about why the result is what it is; may be null
    
    varType - the annotated type of the variable
    
    valueType - the annotated type of the value
    
    valueTree - the location to use when reporting the error message
  - checkArrayInitialization
```
protected void checkArrayInitialization(AnnotatedTypeMirror type,
                                        List<? extends ExpressionTree> initializers)
```
  - checkTypeArguments
```
protected void checkTypeArguments(Tree toptree,
                                  List<? extends AnnotatedTypeParameterBounds> paramBounds,
                                  List<? extends AnnotatedTypeMirror> typeargs,
                                  List<? extends Tree> typeargTrees,
                                  Name typeOrMethodName,
                                  List<?> paramNames)
```
    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:
    
    toptree - the tree for error reporting, only used for inferred type arguments
    
    paramBounds - the bounds of the type parameters from a class or method declaration
    
    typeargs - the type arguments from the type or method invocation
    
    typeargTrees - the type arguments as trees, used for error reporting
  - skipReceiverSubtypeCheck
```
protected boolean skipReceiverSubtypeCheck(MethodInvocationTree node,
                                           AnnotatedTypeMirror methodDefinitionReceiver,
                                           AnnotatedTypeMirror methodCallReceiver)
```
    Indicates whether to skip subtype checks on the receiver when checking method invocability. A visitor may, for example, allow a method to be invoked even if the receivers are siblings in a hierarchy, provided that some other condition (implemented by the visitor) is satisfied.
    
    Parameters:
    
    node - the method invocation node
    
    methodDefinitionReceiver - the ATM of the receiver of the method definition
    
    methodCallReceiver - the ATM of the receiver of the method call
    
    Returns:
    
    whether to skip subtype checks on the receiver
  - checkMethodInvocability
```
protected void checkMethodInvocability(AnnotatedTypeMirror.AnnotatedExecutableType method,
                                       MethodInvocationTree node)
```
    Tests whether the method can be invoked using the receiver of the 'node' method invocation, and issues a "method.invocation.invalid" if the invocation is invalid.
    This implementation tests whether the receiver in the method invocation is a subtype of the method receiver type. This behavior can be specialized by overriding skipReceiverSubtypeCheck.
    
    Parameters:
    
    method - the type of the invoked method
    
    node - the method invocation node
  - reportMethodInvocabilityError
```
protected void reportMethodInvocabilityError(MethodInvocationTree node,
                                             AnnotatedTypeMirror found,
                                             AnnotatedTypeMirror expected)
```
    Report a method invocability error. Allows checkers to change how the message is output.
    
    Parameters:
    
    node - the AST node at which to report the error
    
    found - the actual type of the receiver
    
    expected - the expected type of the receiver
  - checkConstructorInvocation
```
protected void checkConstructorInvocation(AnnotatedTypeMirror.AnnotatedDeclaredType invocation,
                                          AnnotatedTypeMirror.AnnotatedExecutableType constructor,
                                          NewClassTree newClassTree)
```
    Check that the (explicit) annotations on a new class tree are comparable to the result type of the constructor. Issue an error if not.
    Issue a warning if the annotations on the constructor invocation is a subtype of the constructor result type. This is equivalent to down-casting.
  - checkArguments
```
protected void checkArguments(List<? extends AnnotatedTypeMirror> requiredArgs,
                              List<? extends ExpressionTree> passedArgs,
                              Name executableName,
                              List<?> paramNames)
```
    A helper method to check that each passed argument is a subtype of the corresponding required argument, and issues "argument.invalid" error for each passed argument that not a subtype of the required one.
    Note this method requires the lists to have the same length, as it does not handle cases like var args.
    
    Parameters:
    
    requiredArgs - the required types. This may differ from the formal parameter types, because it replaces a varargs parameter by multiple parameters with the vararg's element type.
    
    passedArgs - the expressions passed to the corresponding types
    
    executableName - the name of the method or constructor being called
    
    paramNames - the names of the callee's formal parameters
    
    See Also:
    
    checkVarargs(AnnotatedTypeMirror.AnnotatedExecutableType, Tree)
  - testTypevarContainment
```
protected boolean testTypevarContainment(AnnotatedTypeMirror inner,
                                         AnnotatedTypeMirror outer)
```
    Returns true if both types are type variables and outer contains inner. Outer contains inner implies: inner.upperBound <: outer.upperBound outer.lowerBound <: inner.lowerBound.
    
    Returns:
    
    true if both types are type variables and outer contains inner
  - createOverrideChecker
```
protected BaseTypeVisitor.OverrideChecker createOverrideChecker(Tree overriderTree,
                                                                AnnotatedTypeMirror.AnnotatedExecutableType overrider,
                                                                AnnotatedTypeMirror overridingType,
                                                                AnnotatedTypeMirror overridingReturnType,
                                                                AnnotatedTypeMirror.AnnotatedExecutableType overridden,
                                                                AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType,
                                                                AnnotatedTypeMirror overriddenReturnType)
```
    Create an OverrideChecker.
    This exists so that subclasses can subclass OverrideChecker and use their subclass instead of using OverrideChecker itself.
  - checkOverride
```
protected boolean checkOverride(MethodTree overriderTree,
                                AnnotatedTypeMirror.AnnotatedDeclaredType overridingType,
                                AnnotatedTypeMirror.AnnotatedExecutableType overridden,
                                AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType)
```
    Type checks that a method may override another method. Uses an OverrideChecker subclass as created by createOverrideChecker(com.sun.source.tree.Tree, org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType, org.checkerframework.framework.type.AnnotatedTypeMirror, org.checkerframework.framework.type.AnnotatedTypeMirror, org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType, org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType, org.checkerframework.framework.type.AnnotatedTypeMirror). This version of the method uses the annotated type factory to get the annotated type of the overriding method, and does NOT expose that type.
    
    Parameters:
    
    overriderTree - declaration tree of overriding method
    
    overridingType - type of overriding class
    
    overridden - type of overridden method
    
    overriddenType - type of overridden class
    
    Returns:
    
    true if the override is allowed
    
    See Also:
    
    checkOverride(MethodTree, AnnotatedTypeMirror.AnnotatedExecutableType, AnnotatedTypeMirror.AnnotatedDeclaredType, AnnotatedTypeMirror.AnnotatedExecutableType, AnnotatedTypeMirror.AnnotatedDeclaredType)
  - checkOverride
```
protected boolean checkOverride(MethodTree overriderTree,
                                AnnotatedTypeMirror.AnnotatedExecutableType overrider,
                                AnnotatedTypeMirror.AnnotatedDeclaredType overridingType,
                                AnnotatedTypeMirror.AnnotatedExecutableType overridden,
                                AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType)
```
    Type checks that a method may override another method. Uses an OverrideChecker subclass as created by createOverrideChecker(com.sun.source.tree.Tree, org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType, org.checkerframework.framework.type.AnnotatedTypeMirror, org.checkerframework.framework.type.AnnotatedTypeMirror, org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType, org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType, org.checkerframework.framework.type.AnnotatedTypeMirror). This version of the method exposes AnnotatedExecutableType of the overriding method. Override this version of the method if you need to access that type.
    
    Parameters:
    
    overriderTree - declaration tree of overriding method
    
    overrider - type of the overriding method
    
    overridingType - type of overriding class
    
    overridden - type of overridden method
    
    overriddenType - type of overridden class
    
    Returns:
    
    true if the override is allowed
    
    See Also:
    
    checkOverride(MethodTree, AnnotatedTypeMirror.AnnotatedDeclaredType, AnnotatedTypeMirror.AnnotatedExecutableType, AnnotatedTypeMirror.AnnotatedDeclaredType)
  - checkMethodReferenceAsOverride
```
protected boolean checkMethodReferenceAsOverride(MemberReferenceTree memberReferenceTree,
                                                 Void p)
```
    Check that a method reference is allowed. Using the OverrideChecker class.
    
    Parameters:
    
    memberReferenceTree - the tree for the method reference
    
    Returns:
    
    true if the method reference is allowed
  - enclosingMemberSelect
```
protected MemberSelectTree enclosingMemberSelect()
```
    Call this only when the current path is an identifier.
    
    Returns:
    
    the enclosing member select, or null if the identifier is not the field in a member selection
  - enclosingStatement
```
protected Tree enclosingStatement(@FindDistinct
                                  Tree tree)
```
    Returns the statement that encloses the given one.
    
    Parameters:
    
    tree - an AST node that is on the current path
    
    Returns:
    
    the statement that encloses the given one
  - visitIdentifier
```
public Void visitIdentifier(IdentifierTree node,
                            Void p)
```
    Specified by:
    
    visitIdentifier in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitIdentifier in class TreeScanner<Void,Void>
  - checkAccess
```
protected void checkAccess(IdentifierTree node,
                           Void p)
```
  - isAccessAllowed
```
protected boolean isAccessAllowed(Element field,
                                  AnnotatedTypeMirror receiver,
                                  @FindDistinct
                                  ExpressionTree accessTree)
```
    Returns true if access is allowed, based on an @Unused annotation
    
    Parameters:
    
    field - the field to be accessed, whose declaration might be annotated by @Unused
    
    receiver - the expression whose field is accessed
    
    accessTree - the access expression
    
    Returns:
    
    true if access is allowed
  - isValidUse
```
public boolean isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType,
                          AnnotatedTypeMirror.AnnotatedDeclaredType useType,
                          Tree tree)
```
    Tests that the qualifiers present on the useType are valid qualifiers, given the qualifiers on the declaration of the type, declarationType.
    The check is shallow, as it does not descend into generic or array types (i.e. only performing the validity check on the raw type or outermost array dimension). validateTypeOf(Tree) would call this for each type argument or array dimension separately.
    In most cases, useType simply needs to be a subtype of declarationType. If a type system makes exceptions to this rule, its implementation should override this method.
    
    Parameters:
    
    declarationType - the type of the class (TypeElement)
    
    useType - the use of the class (instance type)
    
    tree - the tree where the type is used
    
    Returns:
    
    true if the useType is a valid use of elemType
  - isValidUse
```
public boolean isValidUse(AnnotatedTypeMirror.AnnotatedPrimitiveType type,
                          Tree tree)
```
    Tests that the qualifiers present on the primitive type are valid.
    
    Parameters:
    
    type - the use of the primitive type
    
    tree - the tree where the type is used
    
    Returns:
    
    true if the type is a valid use of the primitive type
  - isValidUse
```
public boolean isValidUse(AnnotatedTypeMirror.AnnotatedArrayType type,
                          Tree tree)
```
    Tests that the qualifiers present on the array type are valid. This method will be invoked for each array level independently, i.e. this method only needs to check the top-level qualifiers of an array.
    
    Parameters:
    
    type - the array type use
    
    tree - the tree where the type is used
    
    Returns:
    
    true if the type is a valid array type
  - validateTypeOf
```
public boolean validateTypeOf(Tree tree)
```
    Tests whether the tree expressed by the passed type tree is a valid type, and emits an error if that is not the case (e.g. '@Mutable String'). If the tree is a method or constructor, check the return type.
    
    Parameters:
    
    tree - the AST type supplied by the user
  - validateType
```
protected boolean validateType(Tree tree,
                               AnnotatedTypeMirror type)
```
    Tests whether the type and corresponding type tree is a valid type, and emits an error if that is not the case (e.g. '@Mutable String'). If the tree is a method or constructor, check the return type.
    
    Parameters:
    
    tree - the type tree supplied by the user
    
    type - the type corresponding to tree
  - createTypeValidator
```
protected TypeValidator createTypeValidator()
```
  - shouldSkipUses
```
protected final boolean shouldSkipUses(ExpressionTree exprTree)
```
    Tests whether the expression should not be checked because of the tree referring to unannotated classes, as specified in the checker.skipUses property.
    It returns true if exprTree is a method invocation or a field access to a class whose qualified name matches @{link checker.skipUses} expression.
    
    Parameters:
    
    exprTree - any expression tree
    
    Returns:
    
    true if checker should not test exprTree
  - visitCompilationUnit
```
public Void visitCompilationUnit(CompilationUnitTree node,
                                 Void p)
```
    Override Compilation Unit so we won't visit package names or imports.
    
    Specified by:
    
    visitCompilationUnit in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitCompilationUnit in class TreeScanner<Void,Void>

Class BaseTypeVisitor<Factory extends GenericAnnotatedTypeFactory<?,?,?,?>>

Nested Class Summary

Field Summary

Fields inherited from class org.checkerframework.framework.source.SourceVisitor

Constructor Summary

Method Summary

Methods inherited from class org.checkerframework.framework.source.SourceVisitor

Methods inherited from class com.sun.source.util.TreePathScanner

Methods inherited from class com.sun.source.util.TreeScanner

Methods inherited from class java.lang.Object

Field Detail

checker

atypeFactory

positions

visitorState

contractsUtils

TARGET

targetValueElement

typeValidator

Constructor Detail

BaseTypeVisitor

BaseTypeVisitor

Method Detail

createTypeFactory

getTypeFactory

setRoot

scan

visitClass

processClassTree

checkQualifierParameter

checkExtendsImplements

checkFieldInvariantDeclarations

checkDefaultConstructor

visitMethod

checkPurity

checkConstructorResult

reportPurityErrors

checkPostcondition

checkConditionalPostcondition

visitTypeParameter

visitVariable

visitAssignment

visitEnhancedForLoop

visitMethodInvocation

checkThisConstructorCall

checkSuperConstructorCall

checkThisOrSuperConstructorCall

checkVarargs

checkPreconditions

checkContract

typeCheckVectorCopyIntoArgument

visitNewClass

visitLambdaExpression

visitMemberReference

visitReturn

visitAnnotation

visitConditionalExpression

visitUnary

visitCompoundAssignment

visitNewArray

checkTypecastRedundancy

checkTypecastSafety

isTypeCastSafe

visitTypeCast

visitInstanceOf

visitArrayAccess

visitCatch

visitThrow

checkExceptionParameter

getExceptionParameterLowerBoundAnnotations

checkThrownExpression

getThrowUpperBoundAnnotations

commonAssignmentCheck

commonAssignmentCheck

commonAssignmentCheck

commonAssignmentCheckStartDiagnostic

commonAssignmentCheckEndDiagnostic

commonAssignmentCheckEndDiagnostic

checkArrayInitialization

checkTypeArguments