BaseTypeVisitor

java.lang.Object
- com.sun.source.util.TreeScanner<R,P>
- - com.sun.source.util.TreePathScanner<R,P>
  - - checkers.source.SourceVisitor<@Nullable Void,@Nullable Void>
    - - checkers.basetype.BaseTypeVisitor<Checker>

All Implemented Interfaces:

TreeVisitor<@Nullable Void,@Nullable Void>

Direct Known Subclasses:

FenumVisitor, IGJVisitor, ImmutabilityVisitor, InterningVisitor, JavariVisitor, KeyForVisitor, LinearVisitor, LockVisitor, NullnessVisitor, OwnershipVisitor, RawnessVisitor, RegexVisitor, ReportVisitor, UnitsVisitor
```
public class BaseTypeVisitor<Checker extends BaseTypeChecker>
extends SourceVisitor<@Nullable Void,@Nullable 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), which ultimately calls the BaseTypeChecker#isSubtype 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 check, using Checker.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", BaseTypeChecker#isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror), AnnotatedTypeFactory

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected class BaseTypeVisitor.TypeValidator

Nested Classes
Modifier and Type	Class and Description
`protected class`	`BaseTypeVisitor.TypeValidator`

Field Summary

Fields
Modifier and Type	Field and Description
`protected AnnotationUtils`	`annoFactory` The annotation factory to use for creating annotations.
`protected AnnotatedTypes`	`annoTypes` utilities class for annotated types
`protected Checker`	`checker` The checker corresponding to this visitor.
`protected Map<@ReadOnly String,@ReadOnly String>`	`options` The options that were provided to the checker using this visitor.
`protected BaseTypeVisitor.TypeValidator`	`typeValidator`
`protected VisitorState`	`visitorState` For storing visitor state

Fields inherited from class checkers.source.SourceVisitor
atypeFactory, elements, root, trees, types

Constructor Summary

Constructors
Constructor and Description

BaseTypeVisitor(Checker checker, @Nullable CompilationUnitTree root)

Constructors
Constructor and Description
`BaseTypeVisitor(Checker checker, @Nullable CompilationUnitTree root)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`checkAccess(IdentifierTree node, @Nullable Void p)`
`protected void`	`checkArguments(List<? extends @Mutable AnnotatedTypeMirror> requiredArgs, List<? extends ExpressionTree> passedArgs)` 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(@Mutable AnnotatedTypeMirror type, List<? extends ExpressionTree> initializers)`
`protected void`	`checkAssignability(@Mutable AnnotatedTypeMirror varType, @Nullable Tree varTree)` Tests, for a re-assignment, whether the variable is assignable or not.
`protected boolean`	`checkConstructorInvocation(AnnotatedTypeMirror.AnnotatedDeclaredType dt, AnnotatedTypeMirror.AnnotatedExecutableType constructor, @Nullable Tree src)`
`protected void`	`checkDefaultConstructor(@Nullable ClassTree node)`
`protected void`	`checkForAnnotatedJdk()` Warn if the annotated JDK is not being used.
`protected boolean`	`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`	`checkOverride(@Nullable MethodTree overriderTree, AnnotatedTypeMirror.AnnotatedDeclaredType enclosingType, AnnotatedTypeMirror.AnnotatedExecutableType overridden, AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType, @Nullable Void p)` Checks that an overriding method's return type, parameter types, and receiver type are correct with respect to the annotations on the overridden method's return type, parameter types, and receiver type.
`protected void`	`checkTypeArguments(@Nullable Tree toptree, List<? extends AnnotatedTypeMirror.AnnotatedTypeVariable> typevars, List<? extends @Mutable AnnotatedTypeMirror> typeargs, List<? extends @Nullable Tree> typeargTrees)` 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 "generic.argument.invalid" error if they are not.
`protected void`	`checkTypecastRedundancy(TypeCastTree node, @Nullable Void p)`
`protected void`	`checkTypecastSafety(TypeCastTree node, @Nullable Void p)`
`protected void`	`commonAssignmentCheck(@Mutable AnnotatedTypeMirror varType, @Mutable AnnotatedTypeMirror valueType, @Nullable Tree valueTree, @ReadOnly String errorKey)` 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(@Mutable AnnotatedTypeMirror varType, ExpressionTree valueExp, @ReadOnly String errorKey)` 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(@Nullable Tree varTree, ExpressionTree valueExp, @ReadOnly String errorKey)` 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 BaseTypeVisitor.TypeValidator`	`createTypeValidator()`
`protected MemberSelectTree`	`enclosingMemberSelect()`
`protected @Nullable Tree`	`enclosingStatement(@Nullable Tree tree)`
`protected boolean`	`isAccessAllowed(@Nullable Element field, @Mutable AnnotatedTypeMirror receiver, ExpressionTree accessTree)`
`protected boolean`	`isAssignable(@Mutable AnnotatedTypeMirror varType, @Mutable AnnotatedTypeMirror receiverType, @Nullable Tree variable)` Tests whether the variable accessed is an assignable variable or not, given the current scope TODO: document which parameters are nullable; e.g.
`boolean`	`isValidUse(AnnotatedTypeMirror.AnnotatedArrayType type)` Tests that the qualifiers present on the array type are valid.
`boolean`	`isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType, AnnotatedTypeMirror.AnnotatedDeclaredType useType)` 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)` Tests that the qualifiers present on the primitive type are valid.
`protected boolean`	`isVectorCopyInto(AnnotatedTypeMirror.AnnotatedExecutableType method)` Returns true if the method symbol represents `Vector.copyInto`
`@Nullable Void`	`scan(@Nullable Tree tree, @Nullable Void p)`
`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 void`	`typeCheckVectorCopyIntoArgument(MethodInvocationTree node, List<? extends @Mutable AnnotatedTypeMirror> params)` Type checks the method arguments of `Vector.copyInto()`.
`boolean`	`validateTypeOf(@Nullable 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.
`@Nullable Void`	`visitAnnotation(AnnotationTree node, @Nullable Void p)` Ensure that the annotation arguments comply to their declarations.
`@Nullable Void`	`visitArrayAccess(ArrayAccessTree node, @Nullable Void p)`
`@Nullable Void`	`visitAssignment(AssignmentTree node, @Nullable Void p)` Performs two checks: subtyping and assignability checks, using `commonAssignmentCheck(Tree, ExpressionTree, String)`.
`@Nullable Void`	`visitClass(@Nullable ClassTree node, @Nullable Void p)`
`@Nullable Void`	`visitCompilationUnit(@Nullable CompilationUnitTree node, @Nullable Void p)` Override Compilation Unit so we won't visit package names or imports
`@Nullable Void`	`visitCompoundAssignment(CompoundAssignmentTree node, @Nullable Void p)` Performs assignability check using `checkAssignability(AnnotatedTypeMirror, Tree)`.
`@Nullable Void`	`visitConditionalExpression(ConditionalExpressionTree node, @Nullable Void p)` If the computation of the type of the ConditionalExpressionTree in checkers.types.TypeFromTree.TypeFromExpression.visitConditionalExpression(ConditionalExpressionTree, AnnotatedTypeFactory) is correct, the following checks are redundant.
`@Nullable Void`	`visitEnhancedForLoop(EnhancedForLoopTree node, @Nullable 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.
`@Nullable Void`	`visitIdentifier(IdentifierTree node, @Nullable Void p)`
`@Nullable Void`	`visitInstanceOf(InstanceOfTree node, @Nullable Void p)`
`@Nullable Void`	`visitMethod(@Nullable MethodTree node, @Nullable Void p)` Performs pseudo-assignment check: checks that the method obeys override and subtype rules to all overridden methods.
`@Nullable Void`	`visitMethodInvocation(MethodInvocationTree node, @Nullable Void p)` Performs a method invocation check.
`@Nullable Void`	`visitNewArray(NewArrayTree node, @Nullable Void p)`
`@Nullable Void`	`visitNewClass(NewClassTree node, @Nullable Void p)` Performs a new class invocation check.
`@Nullable Void`	`visitParameterizedType(ParameterizedTypeTree node, @Nullable Void p)` Do not override this method! Previously, this method contained some logic, but the main modifier of types was missing.
`@Nullable Void`	`visitReturn(ReturnTree node, @Nullable Void p)` Checks that the type of the return expression is a subtype of the enclosing method required return type.
`@Nullable Void`	`visitTypeCast(TypeCastTree node, @Nullable Void p)`
`@Nullable Void`	`visitTypeParameter(TypeParameterTree node, @Nullable Void p)`
`@Nullable Void`	`visitUnary(UnaryTree node, @Nullable Void p)` Performs assignability check using `checkAssignability(AnnotatedTypeMirror, Tree)`.
`@Nullable Void`	`visitVariable(VariableTree node, @Nullable Void p)`

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 Checker extends BaseTypeChecker checker
```
    The checker corresponding to this visitor.
  - annoFactory
```
protected final AnnotationUtils annoFactory
```
    The annotation factory to use for creating annotations.
  - options
```
protected final Map<@ReadOnly String,@ReadOnly String> options
```
    The options that were provided to the checker using this visitor.
  - annoTypes
```
protected final AnnotatedTypes annoTypes
```
    utilities class for annotated types
  - visitorState
```
protected final VisitorState visitorState
```
    For storing visitor state
  - typeValidator
```
protected final BaseTypeVisitor.TypeValidator typeValidator
```
- Constructor Detail
  - BaseTypeVisitor
```
public BaseTypeVisitor(Checker checker,
               @Nullable CompilationUnitTree root)
```
    Parameters:
    checker - the typechecker associated with this visitor (for callbacks to BaseTypeChecker#isSubtype)
    root - the root of the AST that this visitor operates on
- Method Detail
  - scan
```
public @Nullable Void scan(@Nullable Tree tree,
                  @Nullable Void p)
```
    Overrides:
    
    scan in class TreePathScanner<@Nullable Void,@Nullable Void>
  - visitClass
```
public @Nullable Void visitClass(@Nullable ClassTree node,
                        @Nullable Void p)
```
    Specified by:
    
    visitClass in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitClass in class TreeScanner<@Nullable Void,@Nullable Void>
  - checkDefaultConstructor
```
protected void checkDefaultConstructor(@Nullable ClassTree node)
```
  - visitMethod
```
public @Nullable Void visitMethod(@Nullable MethodTree node,
                         @Nullable 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<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitMethod in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitTypeParameter
```
public @Nullable Void visitTypeParameter(TypeParameterTree node,
                                @Nullable Void p)
```
    Specified by:
    
    visitTypeParameter in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitTypeParameter in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitVariable
```
public @Nullable Void visitVariable(VariableTree node,
                           @Nullable Void p)
```
    Specified by:
    
    visitVariable in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitVariable in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitAssignment
```
public @Nullable Void visitAssignment(AssignmentTree node,
                             @Nullable Void p)
```
    Performs two checks: subtyping and assignability checks, using commonAssignmentCheck(Tree, ExpressionTree, String). If the subtype check fails, it issues a "assignment.type.incompatible" error.
    
    Specified by:
    
    visitAssignment in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitAssignment in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitEnhancedForLoop
```
public @Nullable Void visitEnhancedForLoop(EnhancedForLoopTree node,
                                  @Nullable 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<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitEnhancedForLoop in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitMethodInvocation
```
public @Nullable Void visitMethodInvocation(MethodInvocationTree node,
                                   @Nullable 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<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitMethodInvocation in class TreeScanner<@Nullable Void,@Nullable Void>
  - isVectorCopyInto
```
protected boolean isVectorCopyInto(AnnotatedTypeMirror.AnnotatedExecutableType method)
```
    Returns true if the method symbol represents Vector.copyInto
  - typeCheckVectorCopyIntoArgument
```
protected void typeCheckVectorCopyIntoArgument(MethodInvocationTree node,
                                   List<? extends @Mutable AnnotatedTypeMirror> params)
```
    Type checks the method arguments of Vector.copyInto(). The Checker Framework special-cases the method invocation, as it is type safety cannot be expressed by Java's type system. For a Vector v of type Vectory<E>, the method invocation v.copyInto(arr) is type-safe iff arr is a 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 @Nullable Void visitNewClass(NewClassTree node,
                           @Nullable 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<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitNewClass in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitReturn
```
public @Nullable Void visitReturn(ReturnTree node,
                         @Nullable 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<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitReturn in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitAnnotation
```
public @Nullable Void visitAnnotation(AnnotationTree node,
                             @Nullable 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<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitAnnotation in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitConditionalExpression
```
public @Nullable Void visitConditionalExpression(ConditionalExpressionTree node,
                                        @Nullable Void p)
```
    If the computation of the type of the ConditionalExpressionTree in checkers.types.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<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitConditionalExpression in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitUnary
```
public @Nullable Void visitUnary(UnaryTree node,
                        @Nullable Void p)
```
    Performs assignability check using checkAssignability(AnnotatedTypeMirror, Tree).
    
    Specified by:
    
    visitUnary in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitUnary in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitCompoundAssignment
```
public @Nullable Void visitCompoundAssignment(CompoundAssignmentTree node,
                                     @Nullable Void p)
```
    Performs assignability check using checkAssignability(AnnotatedTypeMirror, Tree).
    
    Specified by:
    
    visitCompoundAssignment in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitCompoundAssignment in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitNewArray
```
public @Nullable Void visitNewArray(NewArrayTree node,
                           @Nullable Void p)
```
    Specified by:
    
    visitNewArray in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitNewArray in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitParameterizedType
```
public final @Nullable Void visitParameterizedType(ParameterizedTypeTree node,
                                    @Nullable Void p)
```
    Do not override this method! Previously, this method contained some logic, but the main modifier of types was missing. It has been merged with the TypeValidator below. This method doesn't need to do anything, as the type is already validated.
    
    Specified by:
    
    visitParameterizedType in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitParameterizedType in class TreeScanner<@Nullable Void,@Nullable Void>
  - checkTypecastRedundancy
```
protected void checkTypecastRedundancy(TypeCastTree node,
                           @Nullable Void p)
```
  - checkTypecastSafety
```
protected void checkTypecastSafety(TypeCastTree node,
                       @Nullable Void p)
```
  - visitTypeCast
```
public @Nullable Void visitTypeCast(TypeCastTree node,
                           @Nullable Void p)
```
    Specified by:
    
    visitTypeCast in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitTypeCast in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitInstanceOf
```
public @Nullable Void visitInstanceOf(InstanceOfTree node,
                             @Nullable Void p)
```
    Specified by:
    
    visitInstanceOf in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitInstanceOf in class TreeScanner<@Nullable Void,@Nullable Void>
  - visitArrayAccess
```
public @Nullable Void visitArrayAccess(ArrayAccessTree node,
                              @Nullable Void p)
```
    Specified by:
    
    visitArrayAccess in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitArrayAccess in class TreeScanner<@Nullable Void,@Nullable Void>
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(@Nullable Tree varTree,
                         ExpressionTree valueExp,
                         @ReadOnly String errorKey)
```
    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 variable
    valueExp - the AST node for the value
    errorKey - the error message to use if the check fails
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(@Mutable AnnotatedTypeMirror varType,
                         ExpressionTree valueExp,
                         @ReadOnly String errorKey)
```
    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
    valueExp - the AST node for the value
    errorKey - the error message to use if the check fails
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(@Mutable AnnotatedTypeMirror varType,
                         @Mutable AnnotatedTypeMirror valueType,
                         @Nullable Tree valueTree,
                         @ReadOnly String errorKey)
```
    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 to use if the check fails
  - checkArrayInitialization
```
protected void checkArrayInitialization(@Mutable AnnotatedTypeMirror type,
                            List<? extends ExpressionTree> initializers)
```
  - checkTypeArguments
```
protected void checkTypeArguments(@Nullable Tree toptree,
                      List<? extends AnnotatedTypeMirror.AnnotatedTypeVariable> typevars,
                      List<? extends @Mutable AnnotatedTypeMirror> typeargs,
                      List<? extends @Nullable Tree> typeargTrees)
```
    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 "generic.argument.invalid" error if they are not.
    
    Parameters:
    toptree - the tree for error reporting, only used for inferred type arguments
    typevars - the type variables 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
  - checkMethodInvocability
```
protected boolean 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.
    
    Parameters:
    method - the type of the invoked method
    node - the method invocation node
    
    Returns:
    true iff the call of 'node' is a valid call
  - checkConstructorInvocation
```
protected boolean checkConstructorInvocation(AnnotatedTypeMirror.AnnotatedDeclaredType dt,
                                 AnnotatedTypeMirror.AnnotatedExecutableType constructor,
                                 @Nullable Tree src)
```
  - checkArguments
```
protected void checkArguments(List<? extends @Mutable AnnotatedTypeMirror> requiredArgs,
                  List<? extends ExpressionTree> passedArgs)
```
    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
    passedArgs - the expressions passed to the corresponding types
  - checkOverride
```
protected boolean checkOverride(@Nullable MethodTree overriderTree,
                    AnnotatedTypeMirror.AnnotatedDeclaredType enclosingType,
                    AnnotatedTypeMirror.AnnotatedExecutableType overridden,
                    AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType,
                    @Nullable Void p)
```
    Checks that an overriding method's return type, parameter types, and receiver type are correct with respect to the annotations on the overridden method's return type, parameter types, and receiver type.
    This method returns the result of the check, but also emits error messages as a side effect.
    
    Parameters:
    overriderTree - the AST node of the overriding method
    enclosingType - the declared type enclosing the overrider method
    overridden - the type of the overridden method
    overriddenType - the declared type enclosing the overridden method
    p - an optional parameter (as supplied to visitor methods)
    
    Returns:
    true if the override check passed, false otherwise
  - checkAssignability
```
protected void checkAssignability(@Mutable AnnotatedTypeMirror varType,
                      @Nullable Tree varTree)
```
    Tests, for a re-assignment, whether the variable is assignable or not. If not, it emits an assignability.invalid error.
    
    Parameters:
    varType - the type of the variable being re-assigned
    varTree - the tree used to access the variable in the assignment
  - isAssignable
```
protected boolean isAssignable(@Mutable AnnotatedTypeMirror varType,
                   @Mutable AnnotatedTypeMirror receiverType,
                   @Nullable Tree variable)
```
    Tests whether the variable accessed is an assignable variable or not, given the current scope TODO: document which parameters are nullable; e.g. receiverType is null in many cases, e.g. local variables.
    
    Parameters:
    varType - the annotated variable type
    variable - tree used to access the variable
    
    Returns:
    true iff variable is assignable in the current scope
  - enclosingMemberSelect
```
protected MemberSelectTree enclosingMemberSelect()
```
  - enclosingStatement
```
protected @Nullable Tree enclosingStatement(@Nullable Tree tree)
```
  - visitIdentifier
```
public @Nullable Void visitIdentifier(IdentifierTree node,
                             @Nullable Void p)
```
    Specified by:
    
    visitIdentifier in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitIdentifier in class TreeScanner<@Nullable Void,@Nullable Void>
  - checkAccess
```
protected void checkAccess(IdentifierTree node,
               @Nullable Void p)
```
  - isAccessAllowed
```
protected boolean isAccessAllowed(@Nullable Element field,
                      @Mutable AnnotatedTypeMirror receiver,
                      ExpressionTree accessTree)
```
  - isValidUse
```
public boolean isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType,
                 AnnotatedTypeMirror.AnnotatedDeclaredType useType)
```
    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.
    For instance, in the IGJ type system, a @Mutable is an invalid qualifier for String, as String is declared as @Immutable String.
    In most cases, useType simply needs to be a subtype of declarationType, but there are exceptions. In IGJ, a variable may be declared @ReadOnly String, even though String is @Immutable String; ReadOnly is not a subtype of Immutable.
    
    Parameters:
    declarationType - the type of the class (TypeElement)
    useType - the use of the class (instance type)
    
    Returns:
    if the useType is a valid use of elemType
  - isValidUse
```
public boolean isValidUse(AnnotatedTypeMirror.AnnotatedPrimitiveType type)
```
    Tests that the qualifiers present on the primitive type are valid. The default implementation always returns true. Subclasses should override this method to limit what annotations are allowed on primitive types.
  - isValidUse
```
public boolean isValidUse(AnnotatedTypeMirror.AnnotatedArrayType type)
```
    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. The default implementation always returns true. Subclasses should override this method to limit what annotations are allowed on array types.
  - validateTypeOf
```
public boolean validateTypeOf(@Nullable 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').
    
    Parameters:
    tree - the AST type supplied by the user
  - createTypeValidator
```
protected BaseTypeVisitor.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 @Nullable Void visitCompilationUnit(@Nullable CompilationUnitTree node,
                                  @Nullable Void p)
```
    Override Compilation Unit so we won't visit package names or imports
    
    Specified by:
    
    visitCompilationUnit in interface TreeVisitor<@Nullable Void,@Nullable Void>
    
    Overrides:
    
    visitCompilationUnit in class TreeScanner<@Nullable Void,@Nullable Void>
  - checkForAnnotatedJdk
```
protected void checkForAnnotatedJdk()
```
    Warn if the annotated JDK is not being used.

Class BaseTypeVisitor<Checker extends BaseTypeChecker>

Nested Class Summary

Field Summary

Fields inherited from class checkers.source.SourceVisitor

Constructor Summary

Method Summary

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

annoFactory

options

annoTypes

visitorState

typeValidator

Constructor Detail

BaseTypeVisitor

Method Detail

scan

visitClass

checkDefaultConstructor

visitMethod

visitTypeParameter

visitVariable

visitAssignment

visitEnhancedForLoop

visitMethodInvocation

isVectorCopyInto

typeCheckVectorCopyIntoArgument

visitNewClass

visitReturn

visitAnnotation

visitConditionalExpression

visitUnary

visitCompoundAssignment

visitNewArray

visitParameterizedType

checkTypecastRedundancy

checkTypecastSafety

visitTypeCast

visitInstanceOf

visitArrayAccess

commonAssignmentCheck

commonAssignmentCheck

commonAssignmentCheck

checkArrayInitialization

checkTypeArguments

checkMethodInvocability

checkConstructorInvocation

checkArguments

checkOverride

checkAssignability

isAssignable

enclosingMemberSelect

enclosingStatement

visitIdentifier

checkAccess

isAccessAllowed

isValidUse

isValidUse

isValidUse

validateTypeOf

createTypeValidator

shouldSkipUses

visitCompilationUnit

checkForAnnotatedJdk