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 helper class (WholeProgramInferenceScenesHelper) that manipulates .jaif files to perform whole-program inference.

Calling an update* method (updateInferredFieldType, updateInferredMethodParameterTypes, updateInferredParameterType, or updateInferredMethodReturnType) 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: an update* method ignores an explicitly annotated field, method return, or method parameter when passed as an argument.

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)

Method Summary

Modifier and Type	Method and Description
void	saveResults() Write all modified scenes into .jaif files.
void	updateInferredConstructorParameterTypes(ObjectCreationNode objectCreationNode, ExecutableElement constructorElt, AnnotatedTypeFactory atf) Updates the parameter types of the constructor created by objectCreationNode based on arguments to the constructor.
void	updateInferredFieldType(FieldAccessNode lhs, Node rhs, ClassTree classTree, AnnotatedTypeFactory atf) Updates the type of the field lhs in the Scene of the class with tree classTree.
void	updateInferredMethodParameterTypes(MethodInvocationNode methodInvNode, Tree receiverTree, ExecutableElement methodElt, AnnotatedTypeFactory atf) Updates the parameter types of the method methodElt in the Scene of the enclosing class based on the arguments to the method invocation.
void	updateInferredMethodParameterTypes(MethodTree methodTree, ExecutableElement methodElt, AnnotatedTypeMirror.AnnotatedExecutableType overriddenMethod, AnnotatedTypeFactory atf) Updates the parameter types of the method methodElt in the Scene of the method's enclosing class based on the overridden method overriddenMethod parameter types.
void	updateInferredMethodReceiverType(MethodTree methodTree, ExecutableElement methodElt, AnnotatedTypeMirror.AnnotatedExecutableType overriddenMethod, AnnotatedTypeFactory atf) Updates the receiver type of the method methodElt in the Scene of the method's enclosing class based on the overridden method overriddenMethod receiver type.
void	updateInferredMethodReturnType(ReturnNode retNode, com.sun.tools.javac.code.Symbol.ClassSymbol classSymbol, MethodTree methodTree, AnnotatedTypeFactory atf) Updates the return type of the method methodTree in the Scene of the class with symbol classSymbol.
void	updateInferredParameterType(LocalVariableNode lhs, Node rhs, ClassTree classTree, MethodTree methodTree, AnnotatedTypeFactory atf) Updates the parameter type represented by lhs of the method methodTree in the Scene of the enclosing class based on assignments to the parameter inside the method body.

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)

Method Detail

updateInferredConstructorParameterTypes

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

Updates the parameter types of the constructor created by objectCreationNode based on arguments to the constructor.

For each parameter in constructorElt:

• If the Scene does not contain an annotated type for that parameter, then the type of the respective value passed as argument in the object creation call objectCreationNode will be added to the parameter in the Scene.
• If the Scene previously contained an annotated type for that parameter, then its new type will be the LUB between the previous type and the type of the respective value passed as argument in the object creation call.

Specified by:

updateInferredConstructorParameterTypes in interface WholeProgramInference

Parameters:

objectCreationNode - the new Object() node

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

constructorElt - the Element of the constructor

updateInferredMethodParameterTypes

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

Updates the parameter types of the method methodElt in the Scene of the method's enclosing class based on the overridden method overriddenMethod parameter types.

For each method parameter in methodElt:

• If the Scene does not contain an annotated type for that parameter, then the type of the respective parameter on the overridden method will be added to the parameter in the Scene.
• If the Scene previously contained an annotated type for that parameter, then its new type will be the LUB between the previous type and the type of the respective parameter on the overridden method.

Specified by:

updateInferredMethodParameterTypes in interface WholeProgramInference

Parameters:

methodTree - the tree of the method that contains the parameter

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

updateInferredMethodParameterTypes

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

Updates the parameter types of the method methodElt in the Scene of the enclosing class based on the arguments to the method invocation.

For each method parameter in methodElt:

• If the Scene does not contain an annotated type for that parameter, then the type of the respective value passed as argument in the method call methodInvNode will be added to the parameter in the Scene.
• If the Scene previously contained an annotated type for that parameter, then its new type will be the LUB between the previous type and the type of the respective value passed as argument in the method call.

Specified by:

updateInferredMethodParameterTypes 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

updateInferredParameterType

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

Updates the parameter type represented by lhs of the method methodTree in the Scene of the enclosing class based on assignments to the parameter inside the method body.

• If the Scene does not contain an annotated type for that parameter, then the type of the respective value passed as argument in the method call methodInvNode will be added to the parameter in the Scene.
• If the Scene previously contained an annotated type for that parameter, then its new type will be the LUB between the previous type and the type of the respective value passed as argument in the method call.

Specified by:

updateInferredParameterType in interface WholeProgramInference

Parameters:

lhs - the node representing the parameter

rhs - the node being assigned to the parameter

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

updateInferredMethodReceiverType

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

Updates the receiver type of the method methodElt in the Scene of the method's enclosing class based on the overridden method overriddenMethod receiver type.

For the receiver in methodElt:

• If the Scene does not contain an annotated type for the receiver, then the type of the receiver on the overridden method will be added to the receiver in the Scene.
• If the Scene previously contained an annotated type for the receiver, then its new type will be the LUB between the previous type and the type of the receiver on the overridden method.

Specified by:

updateInferredMethodReceiverType in interface WholeProgramInference

Parameters:

methodTree - the tree of the method that contains the receiver

methodElt - the element of the method

overriddenMethod - the overridden method

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

updateInferredFieldType

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

Updates the type of the field lhs in the Scene of the class with tree classTree. If the field has a declaration annotation with the IgnoreInWholeProgramInference meta-annotation, no type annotation will be inferred for that field.

If the Scene contains no entry for the field lhs, the entry will be created and its type will be the type of rhs. If the Scene previously contained an entry/type for lhs, its new type will be the LUB between the previous type and the type of rhs.

Specified by:

updateInferredFieldType 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

updateInferredMethodReturnType

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

Updates the return type of the method methodTree in the Scene of the class with symbol classSymbol.

If the Scene does not contain an annotated return type for the method methodTree, then the type of the value passed to the return expression will be added to the return type of that method in the Scene. If the Scene previously contained an annotated return type for the method methodTree, its new type will be the LUB between the previous type and the type of the value passed to the return expression.

Specified by:

updateInferredMethodReturnType 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