org.checkerframework.checker.lock

Class LockVisitor

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

org.checkerframework.checker.lock.LockVisitor

All Implemented Interfaces:

TreeVisitor<Void,Void>

public class LockVisitor
extends BaseTypeVisitor<LockAnnotatedTypeFactory>

The LockVisitor enforces the special type-checking rules described in the Lock Checker manual chapter.

See the Checker Framework Manual:

Lock Checker

Field Summary

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

atypeFactory, checker, contractsUtils, positions, thisPattern, typeValidator, visitorState

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

elements, root, trees, types

Constructor Summary

Constructors

Constructor and Description
LockVisitor(BaseTypeChecker checker)

Method Summary

Modifier and Type	Method and Description
protected boolean	checkOverride(MethodTree overriderTree, AnnotatedTypeMirror.AnnotatedDeclaredType enclosingType, AnnotatedTypeMirror.AnnotatedExecutableType overridden, AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType, Void p) Ensures that subclass methods are annotated with a stronger or equally strong side effect annotation than the parent class method.
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.
LockAnnotatedTypeFactory	createTypeFactory() Constructs an instance of the appropriate type factory for the implemented type system.
protected Set<? extends AnnotationMirror>	getExceptionParameterLowerBoundAnnotations() Returns a set of AnnotationMirrors that is a lower bound for exception parameters.
boolean	isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType declarationType, AnnotatedTypeMirror.AnnotatedDeclaredType useType, Tree tree) Skips the call to super and returns true.
protected FlowExpressions.Receiver	parseExpressionString(String expression, FlowExpressionParseUtil.FlowExpressionContext flowExprContext, TreePath path, Node node, Tree treeForErrorReporting) If expression is "itself", and the flow expression parser cannot find a variable, class, etc.
protected boolean	skipReceiverSubtypeCheck(MethodInvocationTree node, AnnotatedTypeMirror methodDefinitionReceiver, AnnotatedTypeMirror methodCallReceiver) When visiting a method call, if the receiver formal parameter has type @GuardSatisfied and the receiver actual parameter has type @GuardedBy(...), this method verifies that the guard is satisfied, and it returns true, indicating that the receiver subtype check should be skipped.
Void	visitAnnotation(AnnotationTree tree, Void p) Ensure that the annotation arguments comply to their declarations.
Void	visitArrayAccess(ArrayAccessTree tree, Void p)
Void	visitBinary(BinaryTree node, Void p)
Void	visitClass(ClassTree node, Void p) Disallows annotations from the @GuardedBy hierarchy on class declarations (other than @GuardedBy({}).
Void	visitCompoundAssignment(CompoundAssignmentTree node, Void p) Performs assignability check using BaseTypeVisitor.checkAssignability(AnnotatedTypeMirror, Tree).
Void	visitIdentifier(IdentifierTree tree, Void p)
Void	visitMemberSelect(MemberSelectTree tree, Void p)
Void	visitMethod(MethodTree node, Void p) Issues an error if a method (explicitly or implicitly) annotated with @MayReleaseLocks has a formal parameter or receiver (explicitly or implicitly) annotated with @GuardSatisfied.
Void	visitMethodInvocation(MethodInvocationTree node, Void p) When visiting a method invocation, issue an error if the side effect annotation on the called method causes the side effect guarantee of the enclosing method to be violated.
Void	visitSynchronized(SynchronizedTree node, Void p) When visiting a synchronized block, issue an error if the expression has a type that implements the java.util.concurrent.locks.Lock interface.
Void	visitVariable(VariableTree node, Void p)

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

checkAccess, checkArguments, checkArrayInitialization, checkAssignability, checkConditionalPostconditions, checkConditionalPostconditionsConsistency, checkConstructorInvocation, checkContract, checkDefaultConstructor, checkExceptionParameter, checkFlowExprParameters, checkForAnnotatedJdk, checkMethodInvocability, checkMethodReferenceAsOverride, checkPostconditions, checkPostconditionsConsistency, checkPreconditions, checkPreconditions, checkPreconditionsConsistency, checkThrownExpression, checkTypeArguments, checkTypecastRedundancy, checkTypecastSafety, commonAssignmentCheck, commonAssignmentCheck, createTypeValidator, enclosingMemberSelect, enclosingStatement, getThrowUpperBoundAnnotations, getTypeFactory, isAccessAllowed, isAssignable, isValidUse, isValidUse, isVectorCopyInto, reportPurityErrors, scan, setRoot, shouldSkipUses, testTypevarContainment, typeCheckVectorCopyIntoArgument, validateType, validateTypeOf, visitAssignment, visitCatch, visitCompilationUnit, visitConditionalExpression, visitEnhancedForLoop, visitInstanceOf, visitLambdaExpression, visitMemberReference, visitNewArray, visitNewClass, visitParameterizedType, visitReturn, visitThrow, visitTypeCast, visitTypeParameter, visitUnary

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, visitAssert, visitBlock, visitBreak, visitCase, visitContinue, visitDoWhileLoop, visitEmptyStatement, visitErroneous, visitExpressionStatement, visitForLoop, visitIf, visitImport, visitIntersectionType, visitLabeledStatement, visitLiteral, visitModifiers, visitOther, visitParenthesized, visitPrimitiveType, visitSwitch, 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(BaseTypeChecker checker)

Method Detail

visitVariable

public Void visitVariable(VariableTree node,
                          Void p)

Specified by:

visitVariable in interface TreeVisitor<Void,Void>

Overrides:

visitVariable in class BaseTypeVisitor<LockAnnotatedTypeFactory>

createTypeFactory

public LockAnnotatedTypeFactory 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<LockAnnotatedTypeFactory>

Returns:

the appropriate type factory

visitMethod

public Void visitMethod(MethodTree node,
                        Void p)

Issues an error if a method (explicitly or implicitly) annotated with @MayReleaseLocks has a formal parameter or receiver (explicitly or implicitly) annotated with @GuardSatisfied. Also issues an error if a synchronized method has a @LockingFree, @SideEffectFree or @Pure annotation.

Specified by:

visitMethod in interface TreeVisitor<Void,Void>

Overrides:

visitMethod in class BaseTypeVisitor<LockAnnotatedTypeFactory>

Parameters:

node - the MethodTree of the method definition to visit.

skipReceiverSubtypeCheck

protected boolean skipReceiverSubtypeCheck(MethodInvocationTree node,
                                           AnnotatedTypeMirror methodDefinitionReceiver,
                                           AnnotatedTypeMirror methodCallReceiver)

When visiting a method call, if the receiver formal parameter has type @GuardSatisfied and the receiver actual parameter has type @GuardedBy(...), this method verifies that the guard is satisfied, and it returns true, indicating that the receiver subtype check should be skipped. If the receiver actual parameter has type @GuardSatisfied, this method simply returns true without performing any other actions. The method returns false otherwise.

Overrides:

skipReceiverSubtypeCheck in class BaseTypeVisitor<LockAnnotatedTypeFactory>

Parameters:

node - the MethodInvocationTree of the method being called.

methodDefinitionReceiver - the ATM of the formal receiver parameter of the method being called.

methodCallReceiver - the ATM of the receiver argument of the method call.

Returns:

whether the caller can skip the receiver subtype check.

getExceptionParameterLowerBoundAnnotations

protected Set<? extends AnnotationMirror> getExceptionParameterLowerBoundAnnotations()

Description copied from class: BaseTypeVisitor

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)

Overrides:

getExceptionParameterLowerBoundAnnotations in class BaseTypeVisitor<LockAnnotatedTypeFactory>

Returns:

Set of annotation mirrors, one per hierarchy, that from a lower bound of annotations that can be written on an exception parameter

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

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 tree,
                              Void p)

Specified by:

visitMemberSelect in interface TreeVisitor<Void,Void>

Overrides:

visitMemberSelect in class TreeScanner<Void,Void>

checkOverride

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

Ensures that subclass methods are annotated with a stronger or equally strong side effect annotation than the parent class method.

Overrides:

checkOverride in class BaseTypeVisitor<LockAnnotatedTypeFactory>

Parameters:

overriderTree - Declaration tree of overriding method

enclosingType - Type of overriding class

overridden - Type of overridden method

overriddenType - Type of overridden class

Returns:

true if the override is allowed

visitArrayAccess

public Void visitArrayAccess(ArrayAccessTree tree,
                             Void p)

Specified by:

visitArrayAccess in interface TreeVisitor<Void,Void>

Overrides:

visitArrayAccess in class BaseTypeVisitor<LockAnnotatedTypeFactory>

isValidUse

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

Skips the call to super and returns true.

GuardedBy({}) is the default type on class declarations, which is a subtype of the top annotation @GuardedByUnknown. However, it is valid to declare an instance of a class with any annotation from the @GuardedBy hierarchy. Hence, this method returns true for annotations in the @GuardedBy hierarchy.

Also returns true for annotations in the @LockPossiblyHeld hierarchy since the default for that hierarchy is the top type and annotations from that hierarchy cannot be explicitly written in code.

Overrides:

isValidUse in class BaseTypeVisitor<LockAnnotatedTypeFactory>

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

visitMethodInvocation

public Void visitMethodInvocation(MethodInvocationTree node,
                                  Void p)

When visiting a method invocation, issue an error if the side effect annotation on the called method causes the side effect guarantee of the enclosing method to be violated. For example, a method annotated with @ReleasesNoLocks may not call a method annotated with @MayReleaseLocks. Also check that matching @GuardSatisfied(index) on a method's formal receiver/parameters matches those in corresponding locations on the method call site.

Specified by:

visitMethodInvocation in interface TreeVisitor<Void,Void>

Overrides:

visitMethodInvocation in class BaseTypeVisitor<LockAnnotatedTypeFactory>

Parameters:

node - the MethodInvocationTree of the method call being visited.

visitSynchronized

public Void visitSynchronized(SynchronizedTree node,
                              Void p)

When visiting a synchronized block, issue an error if the expression has a type that implements the java.util.concurrent.locks.Lock interface. This prevents explicit locks from being accidentally used as built-in (monitor) locks. This is important because the Lock Checker does not have a mechanism to separately keep track of the explicit lock and the monitor lock of an expression that implements the Lock interface (i.e. there is a @LockHeld annotation used in dataflow, but there are not distinct @MonitorLockHeld and @ExplicitLockHeld annotations). It is assumed that both kinds of locks will never be held for any expression that implements Lock. Additionally, a synchronized block may not be present in a method that has a @LockingFree guarantee or stronger. An error is issued in this case.

Specified by:

visitSynchronized in interface TreeVisitor<Void,Void>

Overrides:

visitSynchronized in class TreeScanner<Void,Void>

Parameters:

node - the SynchronizedTree for the synchronized block being visited.

visitAnnotation

public Void visitAnnotation(AnnotationTree tree,
                            Void p)

Description copied from class: BaseTypeVisitor

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

visitIdentifier

public Void visitIdentifier(IdentifierTree tree,
                            Void p)

Specified by:

visitIdentifier in interface TreeVisitor<Void,Void>

Overrides:

visitIdentifier in class BaseTypeVisitor<LockAnnotatedTypeFactory>

parseExpressionString

protected FlowExpressions.Receiver parseExpressionString(String expression,
                                                         FlowExpressionParseUtil.FlowExpressionContext flowExprContext,
                                                         TreePath path,
                                                         Node node,
                                                         Tree treeForErrorReporting)
                                                  throws FlowExpressionParseUtil.FlowExpressionParseException

If expression is "itself", and the flow expression parser cannot find a variable, class, etc. named "itself", a flow expression receiver for node is returned, unless node is null, in which case null is returned. Also checks that the flow expression is effectively final and issues an error if it is not.

Returns the result of the super implementation otherwise.

Overrides:

parseExpressionString in class BaseTypeVisitor<LockAnnotatedTypeFactory>

Parameters:

expression - the flow expression string to be parsed.

flowExprContext - the flow expression context with respect to which the expression string is to be evaluated.

path - the TreePath from which to obtain the scope relative to which local variables are parsed.

node - the Node immediately prior to which the preconditions checked by the calling method must hold true. Used by overriding implementations. Allowed to be null.

treeForErrorReporting - the Tree used to report parsing errors via checker.report. Used by overriding implementations.

Throws:

FlowExpressionParseUtil.FlowExpressionParseException

visitClass

public Void visitClass(ClassTree node,
                       Void p)

Disallows annotations from the @GuardedBy hierarchy on class declarations (other than @GuardedBy({}).

Specified by:

visitClass in interface TreeVisitor<Void,Void>

Overrides:

visitClass in class BaseTypeVisitor<LockAnnotatedTypeFactory>

visitBinary

public Void visitBinary(BinaryTree node,
                        Void p)

Specified by:

visitBinary in interface TreeVisitor<Void,Void>

Overrides:

visitBinary in class TreeScanner<Void,Void>

visitCompoundAssignment

public Void visitCompoundAssignment(CompoundAssignmentTree node,
                                    Void p)

Description copied from class: BaseTypeVisitor

Performs assignability check using BaseTypeVisitor.checkAssignability(AnnotatedTypeMirror, Tree).

Specified by:

visitCompoundAssignment in interface TreeVisitor<Void,Void>

Overrides:

visitCompoundAssignment in class BaseTypeVisitor<LockAnnotatedTypeFactory>