org.checkerframework.checker.guieffect

Class GuiEffectVisitor

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

org.checkerframework.checker.guieffect.GuiEffectVisitor

All Implemented Interfaces:

TreeVisitor<Void,Void>

public class GuiEffectVisitor
extends BaseTypeVisitor<GuiEffectTypeFactory>

Require that only UI code invokes code with the UI effect.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	GuiEffectVisitor.GuiEffectOverrideChecker

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

BaseTypeVisitor.OverrideChecker

Field Summary

Fields

Modifier and Type	Field and Description
protected ArrayDeque<MethodTree>	currentMethods
protected boolean	debugSpew Whether or not to display debugging information.
protected ArrayDeque<Effect>	effStack

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

atypeFactory, checker, DETERMINISTIC, inferPurity, methodTree, positions, PURE, SIDE_EFFECT_FREE, TARGET, targetValueElement, typeValidator, unusedWhenElement

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

elements, root, trees, treesWithSuppressWarnings, types

Constructor Summary

Constructors

Constructor and Description
GuiEffectVisitor(BaseTypeChecker checker)

Method Summary

Modifier and Type	Method and Description
protected void	checkConstructorResult(AnnotatedTypeMirror.AnnotatedExecutableType constructorType, ExecutableElement constructorElement) Issue a warning if the result type of the constructor is not top.
protected void	checkExtendsImplements(ClassTree classTree) If "@B class Y extends @A X {}", then enforce that @B must be a subtype of @A.
protected void	checkForPolymorphicQualifiers(ClassTree classTree) Issues an "invalid.polymorphic.qualifier" error for all polymorphic annotations written on the class declaration.
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" if the invocation is invalid.
protected BaseTypeVisitor.OverrideChecker	createOverrideChecker(Tree overriderTree, AnnotatedTypeMirror.AnnotatedExecutableType overrider, AnnotatedTypeMirror overridingType, AnnotatedTypeMirror overridingReturnType, AnnotatedTypeMirror.AnnotatedExecutableType overridden, AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType, AnnotatedTypeMirror overriddenReturnType) Create an OverrideChecker.
protected GuiEffectTypeFactory	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) Tests that the qualifiers present on useType are valid qualifiers, given the qualifiers on the declaration of the type, declarationType.
void	processClassTree(ClassTree classTree) Type-check classTree.
Void	visitLambdaExpression(LambdaExpressionTree node, Void p)
Void	visitMethod(MethodTree node, Void p) Checks that the method obeys override and subtype rules to all overridden methods.
Void	visitMethodInvocation(MethodInvocationTree node, Void p) Performs a method invocation check.
Void	visitNewClass(NewClassTree node, Void p) Performs a new class invocation check.

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

checkAccess, checkAccessAllowed, checkArguments, checkArrayInitialization, checkConditionalPostcondition, checkConstructorInvocation, checkContract, checkDefaultConstructor, checkExceptionParameter, checkExplicitAnnotationsOnIntersectionBounds, checkFieldInvariantDeclarations, checkForPolymorphicQualifiers, checkMethodReferenceAsOverride, checkOverride, checkOverride, checkPostcondition, checkPreconditions, checkPurity, checkQualifierParameter, checkSuperConstructorCall, checkThisConstructorCall, checkThisOrSuperConstructorCall, checkThrownExpression, checkTypeArguments, checkTypecastRedundancy, checkTypecastSafety, checkVarargs, commonAssignmentCheck, commonAssignmentCheck, commonAssignmentCheck, commonAssignmentCheckEndDiagnostic, commonAssignmentCheckEndDiagnostic, commonAssignmentCheckStartDiagnostic, createTypeFactoryPublic, createTypeValidator, enclosingMemberSelect, enclosingStatement, getThrowUpperBoundAnnotations, getTypeFactory, isTypeCastSafe, isValidUse, isValidUse, reportMethodInvocabilityError, reportPurityErrors, scan, setRoot, shouldSkipUses, skipReceiverSubtypeCheck, testAnnotationInsertion, testJointJavacJavaParserVisitor, testTypevarContainment, typeCheckVectorCopyIntoArgument, validateType, validateTypeOf, visitAnnotatedType, visitAnnotatedType, visitAnnotation, visitAssignment, visitCatch, visitClass, visitCompilationUnit, visitCompoundAssignment, visitConditionalExpression, visitEnhancedForLoop, visitIdentifier, visitInstanceOf, visitMemberReference, visitNewArray, visitReturn, visitThrow, visitTypeCast, visitTypeParameter, visitUnary, visitVariable, warnAboutIrrelevantJavaTypes

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, visitArrayAccess, visitArrayType, visitAssert, visitBinary, visitBlock, visitBreak, visitCase, visitContinue, visitDoWhileLoop, visitEmptyStatement, visitErroneous, visitExports, visitExpressionStatement, visitForLoop, visitIf, visitImport, visitIntersectionType, visitLabeledStatement, visitLiteral, visitMemberSelect, visitModifiers, visitModule, visitOpens, visitOther, visitPackage, visitParameterizedType, visitParenthesized, visitPrimitiveType, visitProvides, visitRequires, visitSwitch, visitSynchronized, visitTry, visitUnionType, visitUses, visitWhileLoop, visitWildcard

Methods inherited from class java.lang.Object

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

Field Detail

debugSpew

protected final boolean debugSpew

Whether or not to display debugging information.

effStack

protected final ArrayDeque<Effect> effStack

currentMethods

protected final ArrayDeque<MethodTree> currentMethods

Constructor Detail

GuiEffectVisitor

public GuiEffectVisitor(BaseTypeChecker checker)

Method Detail

createTypeFactory

protected GuiEffectTypeFactory 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<GuiEffectTypeFactory>

Returns:

the appropriate type factory

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" 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<GuiEffectTypeFactory>

Parameters:

method - the type of the invoked method

node - the method invocation node

createOverrideChecker

protected BaseTypeVisitor.OverrideChecker createOverrideChecker(Tree overriderTree,
                                                                AnnotatedTypeMirror.AnnotatedExecutableType overrider,
                                                                AnnotatedTypeMirror overridingType,
                                                                AnnotatedTypeMirror overridingReturnType,
                                                                AnnotatedTypeMirror.AnnotatedExecutableType overridden,
                                                                AnnotatedTypeMirror.AnnotatedDeclaredType overriddenType,
                                                                AnnotatedTypeMirror overriddenReturnType)

Description copied from class: BaseTypeVisitor

Create an OverrideChecker.

This exists so that subclasses can subclass OverrideChecker and use their subclass instead of using OverrideChecker itself.

Overrides:

createOverrideChecker in class BaseTypeVisitor<GuiEffectTypeFactory>

Parameters:

overriderTree - the AST node of the overriding method or method reference

overrider - the type of the overriding method

overridingType - the type enclosing the overrider method, usually an AnnotatedDeclaredType; for Method References may be something else

overridingReturnType - the return type of the overriding method

overridden - the type of the overridden method

overriddenType - the declared type enclosing the overridden method

overriddenReturnType - the return type of the overridden method

Returns:

an OverrideChecker

getExceptionParameterLowerBoundAnnotations

protected Set<? extends AnnotationMirror> getExceptionParameterLowerBoundAnnotations()

Description copied from class: BaseTypeVisitor

Returns a set of AnnotationMirrors that is a lower bound for exception parameters.

This implementation returns top; subclasses can change this behavior.

Note: by default this method is called by BaseTypeVisitor.getThrowUpperBoundAnnotations(), so that this annotation is enforced.

Overrides:

getExceptionParameterLowerBoundAnnotations in class BaseTypeVisitor<GuiEffectTypeFactory>

Returns:

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

isValidUse

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

Description copied from class: BaseTypeVisitor

Tests that the qualifiers present on 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.

This method is not called if BaseTypeValidator.shouldCheckTopLevelDeclaredOrPrimitiveType(AnnotatedTypeMirror, Tree) returns false -- by default, it is not called on the top level for locals and expressions. To enforce a type validity property everywhere, override methods such as BaseTypeValidator.visitDeclared(org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType, com.sun.source.tree.Tree) rather than this method.

Overrides:

isValidUse in class BaseTypeVisitor<GuiEffectTypeFactory>

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

visitLambdaExpression

public Void visitLambdaExpression(LambdaExpressionTree node,
                                  Void p)

Specified by:

visitLambdaExpression in interface TreeVisitor<Void,Void>

Overrides:

visitLambdaExpression in class BaseTypeVisitor<GuiEffectTypeFactory>

checkExtendsImplements

protected void checkExtendsImplements(ClassTree classTree)

Description copied from class: BaseTypeVisitor

If "@B class Y extends @A X {}", then enforce that @B must be a subtype of @A.

Also validate the types of the extends and implements clauses.

Overrides:

checkExtendsImplements in class BaseTypeVisitor<GuiEffectTypeFactory>

Parameters:

classTree - class tree to check

checkConstructorResult

protected void checkConstructorResult(AnnotatedTypeMirror.AnnotatedExecutableType constructorType,
                                      ExecutableElement constructorElement)

Description copied from class: BaseTypeVisitor

Issue a warning if the result type of the constructor is not top. If it is a supertype of the class, then a conflicting.annos error will also be issued by BaseTypeVisitor.isValidUse(AnnotatedTypeMirror.AnnotatedDeclaredType,AnnotatedTypeMirror.AnnotatedDeclaredType,Tree).

Overrides:

checkConstructorResult in class BaseTypeVisitor<GuiEffectTypeFactory>

Parameters:

constructorType - AnnotatedExecutableType for the constructor

constructorElement - element that declares the constructor

checkForPolymorphicQualifiers

protected void checkForPolymorphicQualifiers(ClassTree classTree)

Description copied from class: BaseTypeVisitor

Issues an "invalid.polymorphic.qualifier" error for all polymorphic annotations written on the class declaration.

Overrides:

checkForPolymorphicQualifiers in class BaseTypeVisitor<GuiEffectTypeFactory>

Parameters:

classTree - the class to check

visitMethodInvocation

public Void visitMethodInvocation(MethodInvocationTree node,
                                  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<Void,Void>

Overrides:

visitMethodInvocation in class BaseTypeVisitor<GuiEffectTypeFactory>

visitMethod

public Void visitMethod(MethodTree node,
                        Void p)

Description copied from class: BaseTypeVisitor

Checks that the method obeys override and subtype rules to all overridden methods. (Uses the pseudo-assignment logic to do so.)

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<Void,Void>

Overrides:

visitMethod in class BaseTypeVisitor<GuiEffectTypeFactory>

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

processClassTree

public void processClassTree(ClassTree classTree)

Description copied from class: BaseTypeVisitor

Type-check classTree. Subclasses should override this method instead of BaseTypeVisitor.visitClass(ClassTree, Void).

Overrides:

processClassTree in class BaseTypeVisitor<GuiEffectTypeFactory>

Parameters:

classTree - class to check