polyglot.visit

Class InitChecker

java.lang.Object

polyglot.visit.NodeVisitor

polyglot.visit.HaltingVisitor

polyglot.visit.ErrorHandlingVisitor

polyglot.visit.DataFlow<InitChecker.FlowItem>

polyglot.visit.InitChecker

All Implemented Interfaces:

java.lang.Cloneable, Copy<NodeVisitor>

Direct Known Subclasses:

JL5InitChecker

public class InitChecker
extends DataFlow<InitChecker.FlowItem>

Visitor which checks that all local variables must be defined before use, and that final variables and fields are initialized correctly. The checking of the rules is implemented in the methods leaveCall(Node) and check(FlowGraph, Term, Item, Item). If language extensions have new constructs that use local variables, they can override the method checkOther to check that the uses of these local variables are correctly initialized. (The implementation of the method will probably call checkLocalInstanceInit to see if the local used is initialized). If language extensions have new constructs that assign to local variables, they can override the method flowOther to capture the way the new construct's initialization behavior.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	InitChecker.BottomItem
protected static class	InitChecker.ClassBodyInfo This class is just a data structure containing relevant information needed for performing initialization checking of a class declaration.
protected static class	InitChecker.DataFlowItem Dataflow items for this dataflow are maps of VarInstances to counts of the min and max number of times those variables/fields have been initialized.
protected static class	InitChecker.FlowItem
protected static class	InitChecker.InitCount Class representing the initialization counts of variables.
protected static class	InitChecker.MinMaxInitCount Class to record counts of the minimum and maximum number of times a variable or field has been initialized or assigned to.

Nested classes/interfaces inherited from class polyglot.visit.DataFlow

DataFlow.BoolItem<FlowItem extends DataFlow.Item>, DataFlow.ConditionNavigator<FlowItem extends DataFlow.Item>, DataFlow.FlowGraphSource<FlowItem extends DataFlow.Item>, DataFlow.Frame<FlowItem extends DataFlow.Item>, DataFlow.Item

Nested classes/interfaces inherited from interface polyglot.util.Copy

Copy.Util

Field Summary

Fields

Modifier and Type	Field and Description
protected static InitChecker.FlowItem	BOTTOM
protected InitChecker.ClassBodyInfo	currCBI

Fields inherited from class polyglot.visit.DataFlow

dataflowOnEntry, detectBackEdges, flowCounter, flowgraphStack, forward, postordering

Fields inherited from class polyglot.visit.ErrorHandlingVisitor

error, job, nf, ts

Fields inherited from class polyglot.visit.HaltingVisitor

bypass, bypassParent

Constructor Summary

Constructors

Constructor and Description
InitChecker(Job job, TypeSystem ts, NodeFactory nf)

Method Summary

Methods

Modifier and Type	Method and Description
void	check(FlowGraph<InitChecker.FlowItem> graph, Term n, boolean entry, InitChecker.FlowItem inItem, java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> outItems) Check that the conditions of initialization are not broken.
protected void	checkClassBody(FlowGraph<InitChecker.FlowItem> graph, ClassBody cb, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Check that the set of LocalInstances localsUsed, which is the set of locals used in the inner class declared by cb are initialized before the class declaration.
protected void	checkFieldAssign(FlowGraph<InitChecker.FlowItem> graph, FieldAssign a, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Check that the assignment to a field is correct.
protected void	checkLocal(FlowGraph<InitChecker.FlowItem> graph, Local l, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Check that the local variable l is used correctly.
protected void	checkLocalAssign(FlowGraph<InitChecker.FlowItem> graph, LocalAssign a, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Check that the assignment to a local variable is correct.
protected void	checkLocalInstanceInit(LocalInstance li, InitChecker.DataFlowItem dfIn, Position pos)
protected void	checkLocalsUsedByInnerClass(FlowGraph<InitChecker.FlowItem> graph, ClassBody cb, java.util.Set<LocalInstance> localsUsed, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Check that the set of LocalInstances localsUsed, which is the set of locals used in the inner class declared by cb are initialized before the class declaration.
protected void	checkNonStaticFinalFieldsInit(ClassBody cb) Check that each non static final field has been initialized exactly once, taking into account the fact that constructors may call other constructors.
protected void	checkOther(FlowGraph<InitChecker.FlowItem> graph, Node n, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Allow subclasses to override the checking of other nodes, if needed.
protected void	checkStaticFinalFieldsInit(ClassBody cb) Check that each static final field is initialized exactly once.
InitChecker.FlowItem	confluence(java.util.List<InitChecker.FlowItem> inItems, FlowGraph.Peer<InitChecker.FlowItem> peer, FlowGraph<InitChecker.FlowItem> graph) The confluence operator is essentially the union of all of the inItems.
protected InitChecker.FlowItem	confluence(java.util.List<InitChecker.FlowItem> items, java.util.List<FlowGraph.EdgeKey> itemKeys, FlowGraph.Peer<InitChecker.FlowItem> peer, FlowGraph<InitChecker.FlowItem> graph) The confluence operator for Initializers and Constructors needs to be a little special, as we are only concerned with non-exceptional flows in these cases.
InitChecker.FlowItem	createInitialItem(FlowGraph<InitChecker.FlowItem> graph, Term node, boolean entry) The initial item to be given to the entry point of the dataflow contains the init counts for the final fields.
protected void	dataflow(Expr root) Construct a flow graph for the Expr provided, and call dataflow(FlowGraph).
protected NodeVisitor	enterCall(Node parent, Node n) Overridden superclass method.
protected void	finishConstructorDecl(FlowGraph<InitChecker.FlowItem> graph, ConstructorDecl cd, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Perform necessary actions upon seeing the ConstructorDecl cd.
protected void	finishInitializer(FlowGraph<InitChecker.FlowItem> graph, Initializer initializer, InitChecker.DataFlowItem dfIn, InitChecker.DataFlowItem dfOut) Perform necessary actions upon seeing the Initializer initializer.
java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flow(InitChecker.FlowItem trueItem, InitChecker.FlowItem falseItem, InitChecker.FlowItem otherItem, FlowGraph<InitChecker.FlowItem> graph, FlowGraph.Peer<InitChecker.FlowItem> peer) Perform the appropriate flow operations for the Terms.
protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flow(java.util.List<InitChecker.FlowItem> inItems, java.util.List<FlowGraph.EdgeKey> inItemKeys, FlowGraph<InitChecker.FlowItem> graph, FlowGraph.Peer<InitChecker.FlowItem> peer) Produce new Items as appropriate for the peer's node and the input Items.
protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flowConstructorCall(InitChecker.DataFlowItem inItem, FlowGraph<InitChecker.FlowItem> graph, ConstructorCall cc, java.util.Set<FlowGraph.EdgeKey> succEdgeKeys) Perform the appropriate flow operations for a constructor call
protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flowFieldAssign(InitChecker.DataFlowItem inItem, FlowGraph<InitChecker.FlowItem> graph, FieldAssign a, java.util.Set<FlowGraph.EdgeKey> succEdgeKeys) Perform the appropriate flow operations for assignment to a field
protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flowFormal(InitChecker.DataFlowItem inItem, FlowGraph<InitChecker.FlowItem> graph, Formal f, java.util.Set<FlowGraph.EdgeKey> succEdgeKeys) Perform the appropriate flow operations for declaration of a formal parameter
protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flowLocalAssign(InitChecker.DataFlowItem inItem, FlowGraph<InitChecker.FlowItem> graph, LocalAssign a, java.util.Set<FlowGraph.EdgeKey> succEdgeKeys) Perform the appropriate flow operations for assignment to a local variable
protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flowLocalDecl(InitChecker.DataFlowItem inItem, FlowGraph<InitChecker.FlowItem> graph, LocalDecl ld, java.util.Set<FlowGraph.EdgeKey> succEdgeKeys) Perform the appropriate flow operations for declaration of a local variable
protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem>	flowOther(InitChecker.DataFlowItem inItem, FlowGraph<InitChecker.FlowItem> graph, Node n, java.util.Set<FlowGraph.EdgeKey> succEdgeKeys) Allow subclasses to override if necessary.
protected FlowGraph<InitChecker.FlowItem>	initGraph(CodeNode code, Term root) Initialise the FlowGraph to be used in the dataflow analysis.
protected boolean	isFieldsTargetAppropriate(Field f) Determine if we are interested in this field on the basis of the target of the field.
protected Node	leaveCall(Node old, Node n, NodeVisitor v) Postpone the checking of constructors until the end of the class declaration is encountered, to ensure that all initializers are processed first.
protected void	setupClassBody(ClassType ct, ClassBody n)

Methods inherited from class polyglot.visit.DataFlow

check, constructItemsFromCondition, createCFGBuilder, createFrame, createInitialItem, currentFlowGraph, dataflow, dataflow, dataflow, dumpFlowGraph, enterCall, filterItems, filterItemsExceptionSubclass, filterItemsNonError, filterItemsNonException, findSCCs, flow, flow, flow, flowBooleanConditions, flowToBooleanFlow, hasTrueFalseBranches, initGraph, itemsToMap, itemToMap, lang, leave, post, safeConfluence, safeConfluence, safeConfluence

Methods inherited from class polyglot.visit.ErrorHandlingVisitor

begin, catchErrors, enter, enterError, errorQueue, hasErrors, job, leaveCall, leaveCall, nodeFactory, typeSystem

Methods inherited from class polyglot.visit.HaltingVisitor

bypass, bypass, bypassChildren, override, visitChildren

Methods inherited from class polyglot.visit.NodeVisitor

copy, enter, finish, finish, leave, override, toString, visitEdge, visitEdgeNoOverride

Methods inherited from class java.lang.Object

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

Field Detail

currCBI

protected InitChecker.ClassBodyInfo currCBI

BOTTOM

protected static final InitChecker.FlowItem BOTTOM

Constructor Detail

InitChecker

public InitChecker(Job job,
           TypeSystem ts,
           NodeFactory nf)

Method Detail

initGraph

protected FlowGraph<InitChecker.FlowItem> initGraph(CodeNode code,
                                        Term root)

Initialise the FlowGraph to be used in the dataflow analysis.

Overrides:

initGraph in class DataFlow<InitChecker.FlowItem>

Returns:

null if no dataflow analysis should be performed for this code declaration; otherwise, an apropriately initialized FlowGraph.

enterCall

protected NodeVisitor enterCall(Node parent,
                    Node n)
                         throws SemanticException

Overridden superclass method. Set up the state that must be tracked during a Class Declaration.

Overrides:

enterCall in class ErrorHandlingVisitor

n - The root of the subtree to be traversed.

Returns:

The ErrorHandlingVisitor which should be used to visit the children of n.

Throws:

SemanticException

See Also:

NodeVisitor.enter(Node, Node)

leaveCall

protected Node leaveCall(Node old,
             Node n,
             NodeVisitor v)
                  throws SemanticException

Postpone the checking of constructors until the end of the class declaration is encountered, to ensure that all initializers are processed first. Also, at the end of the class declaration, check that all static final fields have been initialized at least once, and that for each constructor all non-static final fields must have been initialized at least once, taking into account the constructor calls.

Overrides:

leaveCall in class DataFlow<InitChecker.FlowItem>

Throws:

SemanticException

setupClassBody

protected void setupClassBody(ClassType ct,
                  ClassBody n)
                       throws SemanticException

Throws:

SemanticException

checkStaticFinalFieldsInit

protected void checkStaticFinalFieldsInit(ClassBody cb)
                                   throws SemanticException

Check that each static final field is initialized exactly once.

Parameters:

cb - The ClassBody of the class declaring the fields to check.

Throws:

SemanticException

checkNonStaticFinalFieldsInit

protected void checkNonStaticFinalFieldsInit(ClassBody cb)
                                      throws SemanticException

Check that each non static final field has been initialized exactly once, taking into account the fact that constructors may call other constructors.

Parameters:

cb - The ClassBody of the class declaring the fields to check.

Throws:

SemanticException

dataflow

protected void dataflow(Expr root)
                 throws SemanticException

Construct a flow graph for the Expr provided, and call dataflow(FlowGraph). Is also responsible for calling post(FlowGraph, Term) after dataflow(FlowGraph) has been called. There is no need to push a CFG onto the stack, as dataflow is not performed on entry in this analysis.

Throws:

SemanticException

createInitialItem

public InitChecker.FlowItem createInitialItem(FlowGraph<InitChecker.FlowItem> graph,
                                     Term node,
                                     boolean entry)

The initial item to be given to the entry point of the dataflow contains the init counts for the final fields.

Specified by:

createInitialItem in class DataFlow<InitChecker.FlowItem>

Returns:

a (possibly null) Item.

confluence

protected InitChecker.FlowItem confluence(java.util.List<InitChecker.FlowItem> items,
                              java.util.List<FlowGraph.EdgeKey> itemKeys,
                              FlowGraph.Peer<InitChecker.FlowItem> peer,
                              FlowGraph<InitChecker.FlowItem> graph)

The confluence operator for Initializers and Constructors needs to be a little special, as we are only concerned with non-exceptional flows in these cases. This method ensures that a slightly different confluence is performed for these Terms, otherwise confluence(List, Term) is called instead.

Overrides:

confluence in class DataFlow<InitChecker.FlowItem>

Parameters:

items - List of Items that flow into node. This method will only be called if the list has at least 2 elements.

itemKeys - List of FlowGraph.ExceptionEdgeKeys for the edges that the corresponding Items in items flowed from.

peer - Peer for which the items are flowing into.

Returns:

a non-null Item.

confluence

public InitChecker.FlowItem confluence(java.util.List<InitChecker.FlowItem> inItems,
                              FlowGraph.Peer<InitChecker.FlowItem> peer,
                              FlowGraph<InitChecker.FlowItem> graph)

The confluence operator is essentially the union of all of the inItems. However, if two or more of the initCount maps from the inItems each have a MinMaxInitCounts entry for the same VarInstance, the conflict must be resolved, by using the minimum of all mins and the maximum of all maxs.

Specified by:

confluence in class DataFlow<InitChecker.FlowItem>

Parameters:

inItems - List of Items that flow into node. this method will only be called if the list has at least 2 elements.

peer - Peer for which the items are flowing into.

Returns:

a non-null Item.

flow

protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flow(java.util.List<InitChecker.FlowItem> inItems,
                                                         java.util.List<FlowGraph.EdgeKey> inItemKeys,
                                                         FlowGraph<InitChecker.FlowItem> graph,
                                                         FlowGraph.Peer<InitChecker.FlowItem> peer)

Description copied from class: DataFlow

Produce new Items as appropriate for the peer's node and the input Items. The default implementation of this method is simply to call confluence for the list of inItems, and pass the result to flow(Item, FlowGraph, Term, Set). Subclasses may want to override this method if a finer-grained dataflow is required. Some subclasses may wish to override this method to call flowToBooleanFlow.

Overrides:

flow in class DataFlow<InitChecker.FlowItem>

Parameters:

inItems - all the Items flowing into the node.

inItemKeys - the FlowGraph.EdgeKeys for the items in the list inItems

graph - the FlowGraph which the dataflow is operating on

Returns:

a Map from FlowGraph.EdgeKeys to Items. The map must have entries for all EdgeKeys in edgeKeys.

flow

public java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flow(InitChecker.FlowItem trueItem,
                                                         InitChecker.FlowItem falseItem,
                                                         InitChecker.FlowItem otherItem,
                                                         FlowGraph<InitChecker.FlowItem> graph,
                                                         FlowGraph.Peer<InitChecker.FlowItem> peer)

Perform the appropriate flow operations for the Terms. This method delegates to other appropriate methods in this class, for modularity. To summarize: - Formals: declaration of a Formal param, just insert a new MinMaxInitCount for the LocalInstance. - LocalDecl: a declaration of a local variable, just insert a new MinMaxInitCount for the LocalInstance as appropriate based on whether the declaration has an initializer or not. - Assign: if the LHS of the assign is a local var or a field that we are interested in, then increment the min and max counts for that local var or field.

Overrides:

flow in class DataFlow<InitChecker.FlowItem>

flowFormal

protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flowFormal(InitChecker.DataFlowItem inItem,
                                                               FlowGraph<InitChecker.FlowItem> graph,
                                                               Formal f,
                                                               java.util.Set<FlowGraph.EdgeKey> succEdgeKeys)

Perform the appropriate flow operations for declaration of a formal parameter

flowLocalDecl

protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flowLocalDecl(InitChecker.DataFlowItem inItem,
                                                                  FlowGraph<InitChecker.FlowItem> graph,
                                                                  LocalDecl ld,
                                                                  java.util.Set<FlowGraph.EdgeKey> succEdgeKeys)

Perform the appropriate flow operations for declaration of a local variable

flowLocalAssign

protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flowLocalAssign(InitChecker.DataFlowItem inItem,
                                                                    FlowGraph<InitChecker.FlowItem> graph,
                                                                    LocalAssign a,
                                                                    java.util.Set<FlowGraph.EdgeKey> succEdgeKeys)

Perform the appropriate flow operations for assignment to a local variable

flowFieldAssign

protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flowFieldAssign(InitChecker.DataFlowItem inItem,
                                                                    FlowGraph<InitChecker.FlowItem> graph,
                                                                    FieldAssign a,
                                                                    java.util.Set<FlowGraph.EdgeKey> succEdgeKeys)

Perform the appropriate flow operations for assignment to a field

flowConstructorCall

protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flowConstructorCall(InitChecker.DataFlowItem inItem,
                                                                        FlowGraph<InitChecker.FlowItem> graph,
                                                                        ConstructorCall cc,
                                                                        java.util.Set<FlowGraph.EdgeKey> succEdgeKeys)

Perform the appropriate flow operations for a constructor call

flowOther

protected java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> flowOther(InitChecker.DataFlowItem inItem,
                                                              FlowGraph<InitChecker.FlowItem> graph,
                                                              Node n,
                                                              java.util.Set<FlowGraph.EdgeKey> succEdgeKeys)

Allow subclasses to override if necessary.

isFieldsTargetAppropriate

protected boolean isFieldsTargetAppropriate(Field f)

Determine if we are interested in this field on the basis of the target of the field. To wit, if the field is static, then the target of the field must be the current class; if the field is not static then the target must be "this".

check

public void check(FlowGraph<InitChecker.FlowItem> graph,
         Term n,
         boolean entry,
         InitChecker.FlowItem inItem,
         java.util.Map<FlowGraph.EdgeKey,InitChecker.FlowItem> outItems)
           throws SemanticException

Check that the conditions of initialization are not broken. To summarize the conditions: - Local variables must be initialized before use, (i.e. min count > 0) - Final local variables (including Formals) cannot be assigned to more than once (i.e. max count <= 1) - Final non-static fields whose target is this cannot be assigned to more than once - Final static fields whose target is the current class cannot be assigned to more than once This method is also responsible for maintaining state between the dataflows over Initializers, by copying back the appropriate MinMaxInitCounts to the map currClassFinalFieldInitCounts.

Specified by:

check in class DataFlow<InitChecker.FlowItem>

Throws:

SemanticException - if the properties this dataflow analysis is checking for is not satisfied.

finishInitializer

protected void finishInitializer(FlowGraph<InitChecker.FlowItem> graph,
                     Initializer initializer,
                     InitChecker.DataFlowItem dfIn,
                     InitChecker.DataFlowItem dfOut)

Perform necessary actions upon seeing the Initializer initializer.

finishConstructorDecl

protected void finishConstructorDecl(FlowGraph<InitChecker.FlowItem> graph,
                         ConstructorDecl cd,
                         InitChecker.DataFlowItem dfIn,
                         InitChecker.DataFlowItem dfOut)

Perform necessary actions upon seeing the ConstructorDecl cd.

checkLocal

protected void checkLocal(FlowGraph<InitChecker.FlowItem> graph,
              Local l,
              InitChecker.DataFlowItem dfIn,
              InitChecker.DataFlowItem dfOut)
                   throws SemanticException

Check that the local variable l is used correctly.

Throws:

SemanticException

checkLocalInstanceInit

protected void checkLocalInstanceInit(LocalInstance li,
                          InitChecker.DataFlowItem dfIn,
                          Position pos)
                               throws SemanticException

Throws:

SemanticException

checkLocalAssign

protected void checkLocalAssign(FlowGraph<InitChecker.FlowItem> graph,
                    LocalAssign a,
                    InitChecker.DataFlowItem dfIn,
                    InitChecker.DataFlowItem dfOut)
                         throws SemanticException

Check that the assignment to a local variable is correct.

Throws:

SemanticException

checkFieldAssign

protected void checkFieldAssign(FlowGraph<InitChecker.FlowItem> graph,
                    FieldAssign a,
                    InitChecker.DataFlowItem dfIn,
                    InitChecker.DataFlowItem dfOut)
                         throws SemanticException

Check that the assignment to a field is correct.

Throws:

SemanticException

checkClassBody

protected void checkClassBody(FlowGraph<InitChecker.FlowItem> graph,
                  ClassBody cb,
                  InitChecker.DataFlowItem dfIn,
                  InitChecker.DataFlowItem dfOut)
                       throws SemanticException

Check that the set of LocalInstances localsUsed, which is the set of locals used in the inner class declared by cb are initialized before the class declaration.

Throws:

SemanticException

checkLocalsUsedByInnerClass

protected void checkLocalsUsedByInnerClass(FlowGraph<InitChecker.FlowItem> graph,
                               ClassBody cb,
                               java.util.Set<LocalInstance> localsUsed,
                               InitChecker.DataFlowItem dfIn,
                               InitChecker.DataFlowItem dfOut)
                                    throws SemanticException

Check that the set of LocalInstances localsUsed, which is the set of locals used in the inner class declared by cb are initialized before the class declaration.

Throws:

SemanticException

checkOther

protected void checkOther(FlowGraph<InitChecker.FlowItem> graph,
              Node n,
              InitChecker.DataFlowItem dfIn,
              InitChecker.DataFlowItem dfOut)
                   throws SemanticException

Allow subclasses to override the checking of other nodes, if needed.

Throws:

SemanticException