NullnessVisitor (checker-framework 2.5.4 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>
      - org.checkerframework.checker.initialization.InitializationVisitor<NullnessAnnotatedTypeFactory,NullnessValue,NullnessStore>
        
        org.checkerframework.checker.nullness.NullnessVisitor

All Implemented Interfaces:: TreeVisitor<Void,Void>

public class NullnessVisitor
extends InitializationVisitor<NullnessAnnotatedTypeFactory,NullnessValue,NullnessStore>

The visitor for the nullness type-system.

Nested Class Summary
- Nested classes/interfaces inherited from class org.checkerframework.common.basetype.BaseTypeVisitor
  BaseTypeVisitor.OverrideChecker

Field Summary
- Fields inherited from class org.checkerframework.checker.initialization.InitializationVisitor
  annoFormatter, initializedFields
- Fields inherited from class org.checkerframework.common.basetype.BaseTypeVisitor
  atypeFactory, checker, contractsUtils, positions, typeValidator, visitorState
- Fields inherited from class org.checkerframework.framework.source.SourceVisitor
  elements, root, trees, treesWithSuppressWarnings, types

Constructor Summary

Constructors
Constructor and Description

NullnessVisitor(BaseTypeChecker checker, boolean useFbc)

Constructors
Constructor and Description
`NullnessVisitor(BaseTypeChecker checker, boolean useFbc)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`checkExceptionParameter(CatchTree node)` Issue error if the exception parameter is not a supertype of the annotation specified by `BaseTypeVisitor.getExceptionParameterLowerBoundAnnotations()`, which is top by default.
`protected void`	`checkForRedundantTests(BinaryTree node)` Reports an error if a comparison of a @NonNull expression with the null literal is performed.
`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 void`	`checkThrownExpression(ThrowTree node)` Case 4: Check for thrown exception nullness.
`protected void`	`commonAssignmentCheck(AnnotatedTypeMirror varType, AnnotatedTypeMirror valueType, Tree valueTree, @CompilerMessageKey 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(AnnotatedTypeMirror varType, ExpressionTree valueExp, @CompilerMessageKey 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(Tree varTree, ExpressionTree valueExp, @CompilerMessageKey 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.
`NullnessAnnotatedTypeFactory`	`createTypeFactory()` Constructs an instance of the appropriate type factory for the implemented type system.
`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`	`visitArrayAccess(ArrayAccessTree node, Void p)` Case 3: Check for array dereferencing.
`Void`	`visitAssert(AssertTree node, Void p)`
`Void`	`visitBinary(BinaryTree node, Void p)` Case 6: Check for redundant nullness tests Case 7: unboxing case: primitive operations.
`Void`	`visitCompoundAssignment(CompoundAssignmentTree node, Void p)` Case 7: unboxing case: primitive operation.
`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`	`visitDoWhileLoop(DoWhileLoopTree node, Void p)`
`Void`	`visitEnhancedForLoop(EnhancedForLoopTree node, Void p)` Case 2: Check for implicit `.iterator` call.
`Void`	`visitForLoop(ForLoopTree node, Void p)`
`Void`	`visitIf(IfTree node, Void p)`
`Void`	`visitMemberSelect(MemberSelectTree node, Void p)` Case 1: Check for null dereferencing.
`Void`	`visitNewArray(NewArrayTree node, Void p)`
`Void`	`visitNewClass(NewClassTree node, Void p)` Performs a new class invocation check.
`Void`	`visitSwitch(SwitchTree node, Void p)`
`Void`	`visitSynchronized(SynchronizedTree node, Void p)` Case 5: Check for synchronizing locks.
`Void`	`visitTypeCast(TypeCastTree node, Void p)` Case 7: unboxing case: casting to a primitive.
`Void`	`visitUnary(UnaryTree node, Void p)` Case 7: unboxing case: primitive operation.
`Void`	`visitWhileLoop(WhileLoopTree node, Void p)`

Methods inherited from class org.checkerframework.checker.initialization.InitializationVisitor
checkConstructorInvocation, checkContract, checkFieldsInitialized, processClassTree, setRoot, visitMethod, visitVariable

Methods inherited from class org.checkerframework.common.basetype.BaseTypeVisitor
checkAccess, checkArguments, checkArrayInitialization, checkAssignability, checkConditionalPostcondition, checkDefaultConstructor, checkFieldInvariantDeclarations, checkForAnnotatedJdk, checkMethodReferenceAsOverride, checkOverride, checkOverride, checkPostcondition, checkPreconditions, checkTypeArguments, checkTypecastRedundancy, checkTypecastSafety, checkVarargs, createOverrideChecker, createTypeValidator, enclosingMemberSelect, enclosingStatement, getExceptionParameterLowerBoundAnnotations, getThrowUpperBoundAnnotations, getTypeFactory, isAccessAllowed, isAssignable, isValidUse, isVectorCopyInto, reportPurityErrors, scan, shouldSkipUses, skipReceiverSubtypeCheck, testTypevarContainment, typeCheckVectorCopyIntoArgument, validateType, validateTypeOf, visitAnnotation, visitAssignment, visitCatch, visitClass, visitCompilationUnit, visitIdentifier, visitInstanceOf, visitLambdaExpression, visitMemberReference, visitMethodInvocation, visitParameterizedType, visitReturn, visitThrow, visitTypeParameter

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 com.sun.source.util.TreeScanner
reduce, scan, visitAnnotatedType, visitArrayType, visitBlock, visitBreak, visitCase, visitContinue, visitEmptyStatement, visitErroneous, visitExpressionStatement, visitImport, visitIntersectionType, visitLabeledStatement, visitLiteral, visitModifiers, visitOther, visitParenthesized, visitPrimitiveType, visitTry, visitUnionType, visitWildcard

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

- Constructor Detail
  - NullnessVisitor
```
public NullnessVisitor(BaseTypeChecker checker,
                       boolean useFbc)
```
- Method Detail
  - createTypeFactory
```
public NullnessAnnotatedTypeFactory createTypeFactory()
```
    Description copied from class: BaseTypeVisitor
    
    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.
    
    Overrides:
    
    createTypeFactory in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    Returns:
    
    the appropriate type factory
  - isValidUse
```
public boolean isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType,
                          AnnotatedTypeMirror.AnnotatedDeclaredType useType,
                          Tree tree)
```
    Description copied from class: BaseTypeVisitor
    
    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). BaseTypeVisitor.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.
    
    Overrides:
    
    isValidUse in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    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)
```
    Description copied from class: BaseTypeVisitor
    
    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.
    
    Overrides:
    
    isValidUse in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    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
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(Tree varTree,
                                     ExpressionTree valueExp,
                                     @CompilerMessageKey String errorKey)
```
    Description copied from class: BaseTypeVisitor
    
    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.
    
    Overrides:
    
    commonAssignmentCheck in class InitializationVisitor<NullnessAnnotatedTypeFactory,NullnessValue,NullnessStore>
    
    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 to use if the check fails (must be a compiler message key, see CompilerMessageKey)
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(AnnotatedTypeMirror varType,
                                     ExpressionTree valueExp,
                                     @CompilerMessageKey String errorKey)
```
    Description copied from class: BaseTypeVisitor
    
    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.
    
    Overrides:
    
    commonAssignmentCheck in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    Parameters:
    
    varType - the annotated type of the lvalue (usually a variable)
    
    valueExp - the AST node for the rvalue (the new value)
    
    errorKey - the error message to use if the check fails (must be a compiler message key, see CompilerMessageKey)
  - commonAssignmentCheck
```
protected void commonAssignmentCheck(AnnotatedTypeMirror varType,
                                     AnnotatedTypeMirror valueType,
                                     Tree valueTree,
                                     @CompilerMessageKey String errorKey)
```
    Description copied from class: BaseTypeVisitor
    
    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.
    
    Overrides:
    
    commonAssignmentCheck in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    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 (must be a compiler message key, see CompilerMessageKey)
  - visitMemberSelect
```
public Void visitMemberSelect(MemberSelectTree node,
                              Void p)
```
    Case 1: Check for null dereferencing.
    
    Specified by:
    
    visitMemberSelect in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitMemberSelect in class TreeScanner<Void,Void>
  - visitEnhancedForLoop
```
public Void visitEnhancedForLoop(EnhancedForLoopTree node,
                                 Void p)
```
    Case 2: Check for implicit .iterator call.
    
    Specified by:
    
    visitEnhancedForLoop in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitEnhancedForLoop in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
  - visitArrayAccess
```
public Void visitArrayAccess(ArrayAccessTree node,
                             Void p)
```
    Case 3: Check for array dereferencing.
    
    Specified by:
    
    visitArrayAccess in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitArrayAccess in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
  - visitNewArray
```
public Void visitNewArray(NewArrayTree node,
                          Void p)
```
    Specified by:
    
    visitNewArray in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitNewArray in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
  - checkThrownExpression
```
protected void checkThrownExpression(ThrowTree node)
```
    Case 4: Check for thrown exception nullness.
    
    Overrides:
    
    checkThrownExpression in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    Parameters:
    
    node - ThrowTree to check
  - visitSynchronized
```
public Void visitSynchronized(SynchronizedTree node,
                              Void p)
```
    Case 5: Check for synchronizing locks.
    
    Specified by:
    
    visitSynchronized in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitSynchronized in class TreeScanner<Void,Void>
  - visitAssert
```
public Void visitAssert(AssertTree node,
                        Void p)
```
    Specified by:
    
    visitAssert in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitAssert in class TreeScanner<Void,Void>
  - visitIf
```
public Void visitIf(IfTree node,
                    Void p)
```
    Specified by:
    
    visitIf in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitIf in class TreeScanner<Void,Void>
  - checkForRedundantTests
```
protected void checkForRedundantTests(BinaryTree node)
```
    Reports an error if a comparison of a @NonNull expression with the null literal is performed.
  - visitBinary
```
public Void visitBinary(BinaryTree node,
                        Void p)
```
    Case 6: Check for redundant nullness tests Case 7: unboxing case: primitive operations.
    
    Specified by:
    
    visitBinary in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitBinary in class TreeScanner<Void,Void>
  - visitUnary
```
public Void visitUnary(UnaryTree node,
                       Void p)
```
    Case 7: unboxing case: primitive operation.
    
    Specified by:
    
    visitUnary in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitUnary in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
  - visitCompoundAssignment
```
public Void visitCompoundAssignment(CompoundAssignmentTree node,
                                    Void p)
```
    Case 7: unboxing case: primitive operation.
    
    Specified by:
    
    visitCompoundAssignment in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitCompoundAssignment in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
  - visitTypeCast
```
public Void visitTypeCast(TypeCastTree node,
                          Void p)
```
    Case 7: unboxing case: casting to a primitive.
    
    Specified by:
    
    visitTypeCast in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitTypeCast in class InitializationVisitor<NullnessAnnotatedTypeFactory,NullnessValue,NullnessStore>
  - checkMethodInvocability
```
protected void checkMethodInvocability(AnnotatedTypeMirror.AnnotatedExecutableType method,
                                       MethodInvocationTree node)
```
    Description copied from class: BaseTypeVisitor
    
    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.
    
    Overrides:
    
    checkMethodInvocability in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    Parameters:
    
    method - the type of the invoked method
    
    node - the method invocation node
  - visitSwitch
```
public Void visitSwitch(SwitchTree node,
                        Void p)
```
    Specified by:
    
    visitSwitch in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitSwitch in class TreeScanner<Void,Void>
  - visitForLoop
```
public Void visitForLoop(ForLoopTree node,
                         Void p)
```
    Specified by:
    
    visitForLoop in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitForLoop in class TreeScanner<Void,Void>
  - visitNewClass
```
public Void visitNewClass(NewClassTree node,
                          Void p)
```
    Description copied from class: BaseTypeVisitor
    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 BaseTypeVisitor<NullnessAnnotatedTypeFactory>
  - visitWhileLoop
```
public Void visitWhileLoop(WhileLoopTree node,
                           Void p)
```
    Specified by:
    
    visitWhileLoop in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitWhileLoop in class TreeScanner<Void,Void>
  - visitDoWhileLoop
```
public Void visitDoWhileLoop(DoWhileLoopTree node,
                             Void p)
```
    Specified by:
    
    visitDoWhileLoop in interface TreeVisitor<Void,Void>
    
    Overrides:
    
    visitDoWhileLoop in class TreeScanner<Void,Void>
  - visitConditionalExpression
```
public Void visitConditionalExpression(ConditionalExpressionTree node,
                                       Void p)
```
    Description copied from class: BaseTypeVisitor
    
    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 BaseTypeVisitor<NullnessAnnotatedTypeFactory>
  - checkExceptionParameter
```
protected void checkExceptionParameter(CatchTree node)
```
    Description copied from class: BaseTypeVisitor
    
    Issue error if the exception parameter is not a supertype of the annotation specified by BaseTypeVisitor.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 BaseTypeVisitor.getExceptionParameterLowerBoundAnnotations().
    
    Overrides:
    
    checkExceptionParameter in class BaseTypeVisitor<NullnessAnnotatedTypeFactory>
    
    Parameters:
    
    node - CatchTree to check

Class NullnessVisitor

Nested Class Summary

Nested classes/interfaces inherited from class org.checkerframework.common.basetype.BaseTypeVisitor

Field Summary

Fields inherited from class org.checkerframework.checker.initialization.InitializationVisitor

Fields inherited from class org.checkerframework.common.basetype.BaseTypeVisitor

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

Constructor Summary

Method Summary

Methods inherited from class org.checkerframework.checker.initialization.InitializationVisitor

Methods inherited from class org.checkerframework.common.basetype.BaseTypeVisitor

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

Constructor Detail

NullnessVisitor

Method Detail

createTypeFactory

isValidUse

isValidUse

commonAssignmentCheck

commonAssignmentCheck

commonAssignmentCheck

visitMemberSelect

visitEnhancedForLoop

visitArrayAccess

visitNewArray

checkThrownExpression

visitSynchronized

visitAssert

visitIf

checkForRedundantTests

visitBinary

visitUnary

visitCompoundAssignment

visitTypeCast

checkMethodInvocability

visitSwitch

visitForLoop

visitNewClass

visitWhileLoop

visitDoWhileLoop

visitConditionalExpression

checkExceptionParameter