org.checkerframework.common.wholeprograminference

Class WholeProgramInferenceScenes

java.lang.Object

org.checkerframework.common.wholeprograminference.WholeProgramInferenceScenes

All Implemented Interfaces:

WholeProgramInference

public class WholeProgramInferenceScenes
extends Object
implements WholeProgramInference

WholeProgramInferenceScenes is an implementation of WholeProgramInference that uses a storage class (WholeProgramInferenceScenesStorage) that manipulates AScenes to perform whole-program inference, and writes them out to a .jaif file at the end.

Calling an update* method replaces the currently-stored type for an element in a AScene, if any, by the LUB of it and the update method's argument.

This class does not perform inference for an element if the element has explicit annotations: calling an update* method on an explicitly annotated field, method return, or method parameter has no effect.

In addition, whole program inference ignores inferred types in a few scenarios. When discovering a use, if:

1. The inferred type of an element that should be written into a .jaif file is a subtype of the upper bounds of this element's currently-written type on the source code.
2. The annotation annotates a null literal, except when doing inference for the NullnessChecker. (The rationale for this is that null is a frequently-used default value, and it would be undesirable to compute any inferred type if null were the only value passed as an argument.)

When outputting a .jaif file, if:

1. The @Target annotation does not permit the annotation to be written at this location.
2. The inferred annotation has the @InvisibleQualifier meta-annotation.
3. The inferred annotation would be the same annotation applied via defaulting — that is, if omitting it has the same effect as writing it.

Constructor Summary

Constructors

Constructor and Description
WholeProgramInferenceScenes(boolean ignoreNullAssignments) Default constructor.

Method Summary

Modifier and Type	Method and Description
void	saveResults() Write all modified scenes into .jaif files.
void	updateFromFieldAssignment(FieldAccessNode lhs, Node rhs, ClassTree classTree, AnnotatedTypeFactory atf) Updates the type of field based on an assignment of rhs to field.
void	updateFromLocalAssignment(LocalVariableNode lhs, Node rhs, ClassTree classTree, MethodTree methodTree, AnnotatedTypeFactory atf) Updates the type of lhs based on an assignment of rhs to lhs.
void	updateFromMethodInvocation(MethodInvocationNode methodInvNode, Tree receiverTree, ExecutableElement methodElt, AnnotatedTypeFactory atf) Updates the parameter types of the method methodElt based on the arguments in the method invocation methodInvNode.
void	updateFromObjectCreation(ObjectCreationNode objectCreationNode, ExecutableElement constructorElt, AnnotatedTypeFactory atf) Updates the parameter types of the constructor constructorElt based on the arguments in objectCreationNode.
void	updateFromOverride(MethodTree methodTree, ExecutableElement methodElt, AnnotatedTypeMirror.AnnotatedExecutableType overriddenMethod, AnnotatedTypeFactory atf) Updates the parameter types (including the receiver) of the method methodTree based on the parameter types of the overridden method overriddenMethod.
void	updateFromReturn(ReturnNode retNode, com.sun.tools.javac.code.Symbol.ClassSymbol classSymbol, MethodTree methodTree, AnnotatedTypeFactory atf) Updates the return type of the method methodTree based on returnedExpression.

Methods inherited from class java.lang.Object

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

Constructor Detail

WholeProgramInferenceScenes

public WholeProgramInferenceScenes(boolean ignoreNullAssignments)

Default constructor.

Parameters:

ignoreNullAssignments - indicates whether assignments where the rhs is null should be ignored

Method Detail

updateFromObjectCreation

public void updateFromObjectCreation(ObjectCreationNode objectCreationNode,
                                     ExecutableElement constructorElt,
                                     AnnotatedTypeFactory atf)

Description copied from interface: WholeProgramInference

Updates the parameter types of the constructor constructorElt based on the arguments in objectCreationNode.

For each parameter in constructorElt:

• If there is no stored annotated type for that parameter, then use the type of the corresponding argument in the object creation call objectCreationNode.
• If there was a stored annotated type for that parameter, then its new type will be the LUB between the previous type and the type of the corresponding argument in the object creation call.

Specified by:

updateFromObjectCreation in interface WholeProgramInference

Parameters:

objectCreationNode - the Node that invokes the constructor

constructorElt - the Element of the constructor

atf - the annotated type factory of a given type system, whose type hierarchy will be used to update the constructor's parameters' types

updateFromMethodInvocation

public void updateFromMethodInvocation(MethodInvocationNode methodInvNode,
                                       Tree receiverTree,
                                       ExecutableElement methodElt,
                                       AnnotatedTypeFactory atf)

Description copied from interface: WholeProgramInference

Updates the parameter types of the method methodElt based on the arguments in the method invocation methodInvNode.

For each formal parameter in methodElt (including the receiver):

• If there is no stored annotated type for that parameter, then use the type of the corresponding argument in the method call methodInvNode.
• If there was a stored annotated type for that parameter, then its new type will be the LUB between the previous type and the type of the corresponding argument in the method call.

Specified by:

updateFromMethodInvocation in interface WholeProgramInference

Parameters:

methodInvNode - the node representing a method invocation

receiverTree - the Tree of the class that contains the method being invoked

methodElt - the element of the method being invoked

atf - the annotated type factory of a given type system, whose type hierarchy will be used to update the method parameters' types

updateFromOverride

public void updateFromOverride(MethodTree methodTree,
                               ExecutableElement methodElt,
                               AnnotatedTypeMirror.AnnotatedExecutableType overriddenMethod,
                               AnnotatedTypeFactory atf)

Description copied from interface: WholeProgramInference

Updates the parameter types (including the receiver) of the method methodTree based on the parameter types of the overridden method overriddenMethod.

For each formal parameter in methodElt:

• If there is no stored annotated type for that parameter, then use the type of the corresponding parameter on the overridden method.
• If there is a stored annotated type for that parameter, then its new type will be the LUB between the previous type and the type of the corresponding parameter on the overridden method.

Specified by:

updateFromOverride in interface WholeProgramInference

Parameters:

methodTree - the tree of the method that contains the parameter(s)

methodElt - the element of the method

overriddenMethod - the AnnotatedExecutableType of the overridden method

atf - the annotated type factory of a given type system, whose type hierarchy will be used to update the parameter type

updateFromLocalAssignment

public void updateFromLocalAssignment(LocalVariableNode lhs,
                                      Node rhs,
                                      ClassTree classTree,
                                      MethodTree methodTree,
                                      AnnotatedTypeFactory atf)

Description copied from interface: WholeProgramInference

Updates the type of lhs based on an assignment of rhs to lhs.

• If there is no stored annotated type for lhs, then use the type of the corresponding argument in the method call methodInvNode.
• If there is a stored annotated type for lhs, then its new type will be the LUB between the previous type and the type of the corresponding argument in the method call.

Specified by:

updateFromLocalAssignment in interface WholeProgramInference

Parameters:

lhs - the node representing the local variable, such as a formal parameter

rhs - the node being assigned to the parameter in the method body

classTree - the tree of the class that contains the parameter

methodTree - the tree of the method that contains the parameter

atf - the annotated type factory of a given type system, whose type hierarchy will be used to update the parameter type

updateFromFieldAssignment

public void updateFromFieldAssignment(FieldAccessNode lhs,
                                      Node rhs,
                                      ClassTree classTree,
                                      AnnotatedTypeFactory atf)

Description copied from interface: WholeProgramInference

Updates the type of field based on an assignment of rhs to field. If the field has a declaration annotation with the IgnoreInWholeProgramInference meta-annotation, no type annotation will be inferred for that field.

If there is no stored entry for the field lhs, the entry will be created and its type will be the type of rhs. If there is a stored entry/type for lhs, its new type will be the LUB between the previous type and the type of rhs.

Specified by:

updateFromFieldAssignment in interface WholeProgramInference

Parameters:

lhs - the field whose type will be refined

rhs - the expression being assigned to the field

classTree - the ClassTree for the enclosing class of the assignment

atf - the annotated type factory of a given type system, whose type hierarchy will be used to update the field's type

updateFromReturn

public void updateFromReturn(ReturnNode retNode,
                             com.sun.tools.javac.code.Symbol.ClassSymbol classSymbol,
                             MethodTree methodTree,
                             AnnotatedTypeFactory atf)

Description copied from interface: WholeProgramInference

Updates the return type of the method methodTree based on returnedExpression.

If there is no stored annotated return type for the method methodTree, then the type of the return expression will be added to the return type of that method. If there is a stored annotated return type for the method methodTree, its new type will be the LUB between the previous type and the type of the return expression.

Specified by:

updateFromReturn in interface WholeProgramInference

Parameters:

retNode - the node that contains the expression returned

classSymbol - the symbol of the class that contains the method

methodTree - the tree of the method whose return type may be updated

atf - the annotated type factory of a given type system, whose type hierarchy will be used to update the method's return type

saveResults

public void saveResults()

Write all modified scenes into .jaif files.

Specified by:

saveResults in interface WholeProgramInference