checkers.nullness

Class NullnessVisitor

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<NullnessSubchecker>

checkers.nullness.NullnessVisitor

All Implemented Interfaces:

TreeVisitor<@Nullable Void,@Nullable Void>

public class NullnessVisitor
extends BaseTypeVisitor<NullnessSubchecker>

A type-checking visitor for the Nullness type system. This visitor reports errors ("dereference.of.nullable") or warnings for violations for the following cases:

1. the receiver of a member dereference is not NonNull
2. the receiver of an implicit ".iterator()" dereference in an enhanced for loop is not NonNull
3. an accessed array is not NonNull
4. a thrown exception is not NonNull
5. the lock in a synchronized block is not NonNull
6. a NonNull reference is checked for nullness
7. a value in implicit unboxed operation is not NonNull

Self-accesses (via this or super) can always be dereferenced.

See Also:

NullnessSubchecker

Nested Class Summary

Nested classes/interfaces inherited from class checkers.basetype.BaseTypeVisitor

BaseTypeVisitor.TypeValidator

Field Summary

Fields inherited from class checkers.basetype.BaseTypeVisitor

annoFactory, annoTypes, checker, options, typeValidator, visitorState

Fields inherited from class checkers.source.SourceVisitor

atypeFactory, elements, root, trees, types

Constructor Summary

Constructors

Constructor and Description
NullnessVisitor(NullnessSubchecker checker, @Nullable CompilationUnitTree root) Creates a new visitor for type-checking NonNull.

Method Summary

Methods

Modifier and Type	Method and Description
protected void	checkDefaultConstructor(@Nullable ClassTree node)
protected void	checkForRedundantTests(BinaryTree node)
protected boolean	checkMethodInvocability(AnnotatedTypeMirror.AnnotatedExecutableType method, MethodInvocationTree node) Special casing NonNull and Raw method calls
protected boolean	checkOverride(@Nullable MethodTree overriderTree, AnnotatedTypeMirror.AnnotatedDeclaredType enclosingType, AnnotatedTypeMirror.AnnotatedExecutableType overridden, AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType, @Nullable Void p) Ensure that also the method post-condition annotations (like @AssertNonNullAfter) are overridden consistently: at least the same fields have to be listed in the overriding method.
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 Pair<Set<VariableElement>,Set<VariableElement>>	getUninitializedFields(@Nullable ClassTree classTree, List<? extends @Nullable AnnotationMirror> annos)
static boolean	isPrimitive(ExpressionTree tree)
static boolean	isString(Types types, TypeMirror stringType, ExpressionTree tree)
static boolean	isUnboxingOperation(Types types, TypeMirror stringType, BinaryTree tree)
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.
@Nullable Void	visitArrayAccess(ArrayAccessTree node, @Nullable Void p) Case 3: Check for array dereferencing
@Nullable Void	visitAssert(AssertTree node, @Nullable Void p)
@Nullable Void	visitAssignment(AssignmentTree node, @Nullable Void p) Performs two checks: subtyping and assignability checks, using BaseTypeVisitor.commonAssignmentCheck(Tree, ExpressionTree, String).
@Nullable Void	visitBinary(BinaryTree node, @Nullable Void p) Case 6: Check for redundant nullness tests Case 7: unboxing case: primitive operations
@Nullable Void	visitCompoundAssignment(CompoundAssignmentTree node, @Nullable Void p) Case 7: unboxing case: primitive operation
@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	visitDoWhileLoop(DoWhileLoopTree node, @Nullable Void p)
@Nullable Void	visitEnhancedForLoop(EnhancedForLoopTree node, @Nullable Void p) Case 2: Check for implicit .iterator call
@Nullable Void	visitForLoop(ForLoopTree node, @Nullable Void p)
@Nullable Void	visitIf(IfTree node, @Nullable Void p)
@Nullable Void	visitMemberSelect(MemberSelectTree node, @Nullable Void p) Case 1: Check for null dereferencing
@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	visitSwitch(SwitchTree node, @Nullable Void p)
@Nullable Void	visitSynchronized(SynchronizedTree node, @Nullable Void p) Case 5: Check for synchronizing locks
@Nullable Void	visitThrow(ThrowTree node, @Nullable Void p) Case 4: Check for thrown exception nullness
@Nullable Void	visitTypeCast(TypeCastTree node, @Nullable Void p) Case 7: unboxing case: casting to a primitive
@Nullable Void	visitUnary(UnaryTree node, @Nullable Void p) Case 7: unboxing case: primitive operation
@Nullable Void	visitWhileLoop(WhileLoopTree node, @Nullable Void p)

Methods inherited from class checkers.basetype.BaseTypeVisitor

checkAccess, checkArguments, checkArrayInitialization, checkAssignability, checkConstructorInvocation, checkForAnnotatedJdk, checkTypeArguments, checkTypecastRedundancy, checkTypecastSafety, commonAssignmentCheck, commonAssignmentCheck, createTypeValidator, enclosingMemberSelect, enclosingStatement, isAccessAllowed, isAssignable, isValidUse, isVectorCopyInto, scan, shouldSkipUses, typeCheckVectorCopyIntoArgument, validateTypeOf, visitAnnotation, visitClass, visitCompilationUnit, visitIdentifier, visitInstanceOf, visitNewClass, visitParameterizedType, visitReturn, visitTypeParameter, visitVariable

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, visitCatch, visitContinue, visitEmptyStatement, visitErroneous, visitExpressionStatement, visitImport, visitLabeledStatement, visitLambdaExpression, visitLiteral, visitMemberReference, 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(NullnessSubchecker checker,
               @Nullable CompilationUnitTree root)

Creates a new visitor for type-checking NonNull.

Parameters:

checker - the checker to use

root - the root of the input program's AST to check

Method Detail

visitMemberSelect

public @Nullable Void visitMemberSelect(MemberSelectTree node,
                               @Nullable Void p)

Case 1: Check for null dereferencing

Specified by:

visitMemberSelect in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitMemberSelect in class TreeScanner<@Nullable Void,@Nullable Void>

visitEnhancedForLoop

public @Nullable Void visitEnhancedForLoop(EnhancedForLoopTree node,
                                  @Nullable Void p)

Case 2: Check for implicit .iterator call

Specified by:

visitEnhancedForLoop in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitEnhancedForLoop in class BaseTypeVisitor<NullnessSubchecker>

visitArrayAccess

public @Nullable Void visitArrayAccess(ArrayAccessTree node,
                              @Nullable Void p)

Case 3: Check for array dereferencing

Specified by:

visitArrayAccess in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitArrayAccess in class BaseTypeVisitor<NullnessSubchecker>

visitNewArray

public @Nullable Void visitNewArray(NewArrayTree node,
                           @Nullable Void p)

Specified by:

visitNewArray in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitNewArray in class BaseTypeVisitor<NullnessSubchecker>

visitThrow

public @Nullable Void visitThrow(ThrowTree node,
                        @Nullable Void p)

Case 4: Check for thrown exception nullness

Specified by:

visitThrow in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitThrow in class TreeScanner<@Nullable Void,@Nullable Void>

visitSynchronized

public @Nullable Void visitSynchronized(SynchronizedTree node,
                               @Nullable Void p)

Case 5: Check for synchronizing locks

Specified by:

visitSynchronized in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitSynchronized in class TreeScanner<@Nullable Void,@Nullable Void>

visitAssert

public @Nullable Void visitAssert(AssertTree node,
                         @Nullable Void p)

Specified by:

visitAssert in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitAssert in class TreeScanner<@Nullable Void,@Nullable Void>

visitConditionalExpression

public @Nullable Void visitConditionalExpression(ConditionalExpressionTree node,
                                        @Nullable Void p)

Description copied from class: BaseTypeVisitor

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 BaseTypeVisitor<NullnessSubchecker>

visitIf

public @Nullable Void visitIf(IfTree node,
                     @Nullable Void p)

Specified by:

visitIf in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitIf in class TreeScanner<@Nullable Void,@Nullable Void>

visitDoWhileLoop

public @Nullable Void visitDoWhileLoop(DoWhileLoopTree node,
                              @Nullable Void p)

Specified by:

visitDoWhileLoop in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitDoWhileLoop in class TreeScanner<@Nullable Void,@Nullable Void>

visitWhileLoop

public @Nullable Void visitWhileLoop(WhileLoopTree node,
                            @Nullable Void p)

Specified by:

visitWhileLoop in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitWhileLoop in class TreeScanner<@Nullable Void,@Nullable Void>

visitForLoop

public @Nullable Void visitForLoop(ForLoopTree node,
                          @Nullable Void p)

Specified by:

visitForLoop in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitForLoop in class TreeScanner<@Nullable Void,@Nullable Void>

visitSwitch

public @Nullable Void visitSwitch(SwitchTree node,
                         @Nullable Void p)

Specified by:

visitSwitch in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitSwitch in class TreeScanner<@Nullable Void,@Nullable Void>

checkForRedundantTests

protected void checkForRedundantTests(BinaryTree node)

visitBinary

public @Nullable Void visitBinary(BinaryTree node,
                         @Nullable Void p)

Case 6: Check for redundant nullness tests Case 7: unboxing case: primitive operations

Specified by:

visitBinary in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitBinary in class TreeScanner<@Nullable Void,@Nullable Void>

visitUnary

public @Nullable Void visitUnary(UnaryTree node,
                        @Nullable Void p)

Case 7: unboxing case: primitive operation

Specified by:

visitUnary in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitUnary in class BaseTypeVisitor<NullnessSubchecker>

visitCompoundAssignment

public @Nullable Void visitCompoundAssignment(CompoundAssignmentTree node,
                                     @Nullable Void p)

Case 7: unboxing case: primitive operation

Specified by:

visitCompoundAssignment in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitCompoundAssignment in class BaseTypeVisitor<NullnessSubchecker>

visitTypeCast

public @Nullable Void visitTypeCast(TypeCastTree node,
                           @Nullable Void p)

Case 7: unboxing case: casting to a primitive

Specified by:

visitTypeCast in interface TreeVisitor<@Nullable Void,@Nullable Void>

Overrides:

visitTypeCast in class BaseTypeVisitor<NullnessSubchecker>

commonAssignmentCheck

protected void commonAssignmentCheck(@Nullable Tree varTree,
                         ExpressionTree valueExp,
                         @ReadOnly 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<NullnessSubchecker>

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

visitMethod

public @Nullable Void visitMethod(@Nullable MethodTree node,
                         @Nullable Void p)

Description copied from class: BaseTypeVisitor

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 BaseTypeVisitor<NullnessSubchecker>

visitMethodInvocation

public @Nullable Void visitMethodInvocation(MethodInvocationTree node,
                                   @Nullable Void p)

Description copied from class: BaseTypeVisitor

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 BaseTypeVisitor<NullnessSubchecker>

checkDefaultConstructor

protected void checkDefaultConstructor(@Nullable ClassTree node)

Overrides:

checkDefaultConstructor in class BaseTypeVisitor<NullnessSubchecker>

visitAssignment

public @Nullable Void visitAssignment(AssignmentTree node,
                             @Nullable Void p)

Description copied from class: BaseTypeVisitor

Performs two checks: subtyping and assignability checks, using BaseTypeVisitor.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 BaseTypeVisitor<NullnessSubchecker>

getUninitializedFields

protected Pair<Set<VariableElement>,Set<VariableElement>> getUninitializedFields(@Nullable ClassTree classTree,
                                                                     List<? extends @Nullable AnnotationMirror> annos)

checkMethodInvocability

protected boolean checkMethodInvocability(AnnotatedTypeMirror.AnnotatedExecutableType method,
                              MethodInvocationTree node)

Special casing NonNull and Raw method calls

Overrides:

checkMethodInvocability in class BaseTypeVisitor<NullnessSubchecker>

Parameters:

method - the type of the invoked method

node - the method invocation node

Returns:

true iff the call of 'node' is a valid call

checkOverride

protected boolean checkOverride(@Nullable MethodTree overriderTree,
                    AnnotatedTypeMirror.AnnotatedDeclaredType enclosingType,
                    AnnotatedTypeMirror.AnnotatedExecutableType overridden,
                    AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType,
                    @Nullable Void p)

Ensure that also the method post-condition annotations (like @AssertNonNullAfter) are overridden consistently: at least the same fields have to be listed in the overriding method.

Overrides:

checkOverride in class BaseTypeVisitor<NullnessSubchecker>

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

isUnboxingOperation

public static final boolean isUnboxingOperation(Types types,
                          TypeMirror stringType,
                          BinaryTree tree)

Returns:

true if binary operation could cause an unboxing operation

isString

public static final boolean isString(Types types,
               TypeMirror stringType,
               ExpressionTree tree)

Returns:

true if the type of the tree is a super of String

isPrimitive

public static final boolean isPrimitive(ExpressionTree tree)

Returns:

true if the type of the tree is a primitive

isValidUse

public boolean isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType,
                 AnnotatedTypeMirror.AnnotatedDeclaredType useType)

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.

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.

Overrides:

isValidUse in class BaseTypeVisitor<NullnessSubchecker>

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)

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<NullnessSubchecker>