checkers.lock

Class LockVisitor

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

checkers.lock.LockVisitor

All Implemented Interfaces:

TreeVisitor<@Nullable Void,@Nullable Void>

public class LockVisitor
extends BaseTypeVisitor<LockChecker>

A type-checking visitor for the Lock type system. This visitor reports errors ("unguarded.access") or warnings for violations for accessing a field or calling a method without holding their locks.

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

elements, root, trees, types

Constructor Summary

Constructors

Constructor and Description
LockVisitor(LockChecker checker, @Nullable CompilationUnitTree root)

Method Summary

Methods

Modifier and Type	Method and Description
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 static boolean	hasGuardedBy(@Mutable AnnotatedTypeMirror t)
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.
protected List<@ReadOnly String>	methodHolding(@NonNull ExecutableElement element)
@Nullable Void	visitIdentifier(IdentifierTree node, @Nullable Void p)
@Nullable Void	visitMemberSelect(MemberSelectTree 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	visitSynchronized(SynchronizedTree node, @Nullable Void p)

Methods inherited from class checkers.basetype.BaseTypeVisitor

checkAccess, checkArguments, checkArrayInitialization, checkAssignability, checkConstructorInvocation, checkDefaultConstructor, checkForAnnotatedJdk, checkTypeArguments, checkTypecastRedundancy, checkTypecastSafety, commonAssignmentCheck, commonAssignmentCheck, commonAssignmentCheck, createTypeValidator, enclosingMemberSelect, enclosingStatement, isAccessAllowed, isAssignable, isValidUse, isValidUse, isVectorCopyInto, scan, shouldSkipUses, typeCheckVectorCopyIntoArgument, validateTypeOf, visitAnnotation, visitArrayAccess, visitAssignment, visitClass, visitCompilationUnit, visitCompoundAssignment, visitConditionalExpression, visitEnhancedForLoop, visitInstanceOf, visitNewArray, visitNewClass, visitParameterizedType, visitReturn, visitTypeCast, visitTypeParameter, visitUnary, 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, visitAssert, visitBinary, visitBlock, visitBreak, visitCase, visitCatch, visitContinue, visitDoWhileLoop, visitEmptyStatement, visitErroneous, visitExpressionStatement, visitForLoop, visitIf, visitImport, visitLabeledStatement, visitLambdaExpression, visitLiteral, visitMemberReference, visitModifiers, visitOther, visitParenthesized, visitPrimitiveType, visitSwitch, visitThrow, visitTry, visitUnionType, visitWhileLoop, visitWildcard

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LockVisitor

public LockVisitor(LockChecker checker,
           @Nullable CompilationUnitTree root)

Method Detail

visitIdentifier

public @Nullable Void visitIdentifier(IdentifierTree node,
                             @Nullable Void p)

Specified by:

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

Overrides:

visitIdentifier in class BaseTypeVisitor<LockChecker>

visitMemberSelect

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

Specified by:

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

Overrides:

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

hasGuardedBy

protected static boolean hasGuardedBy(@Mutable AnnotatedTypeMirror t)

visitSynchronized

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

Specified by:

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

Overrides:

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

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

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

checkOverride

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

Description copied from class: BaseTypeVisitor

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.

Overrides:

checkOverride in class BaseTypeVisitor<LockChecker>

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

checkMethodInvocability

protected boolean 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.

Overrides:

checkMethodInvocability in class BaseTypeVisitor<LockChecker>

Parameters:

method - the type of the invoked method

node - the method invocation node

Returns:

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

methodHolding

protected List<@ReadOnly String> methodHolding(@NonNull ExecutableElement element)

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

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