polyglot.visit

Class DefiniteAssignmentChecker

java.lang.Object

polyglot.visit.NodeVisitor

polyglot.visit.HaltingVisitor

polyglot.visit.ErrorHandlingVisitor

polyglot.visit.DataFlow<DefiniteAssignmentChecker.FlowItem>

polyglot.visit.DefiniteAssignmentChecker

All Implemented Interfaces:

java.lang.Cloneable, Copy<NodeVisitor>

Direct Known Subclasses:

JL5DefiniteAssignmentChecker

public class DefiniteAssignmentChecker
extends DataFlow<DefiniteAssignmentChecker.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	DefiniteAssignmentChecker.AssignmentStatus Class representing the initialization counts of variables.
protected static class	DefiniteAssignmentChecker.ClassBodyInfo This class is just a data structure containing relevant information needed for performing initialization checking of a class declaration.
protected static class	DefiniteAssignmentChecker.FlowItem 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.

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 DefiniteAssignmentChecker.FlowItem	BOTTOM
protected DefiniteAssignmentChecker.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
DefiniteAssignmentChecker(Job job, TypeSystem ts, NodeFactory nf)

Method Summary

Methods

Modifier and Type	Method and Description
void	check(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, Term n, boolean entry, DefiniteAssignmentChecker.FlowItem inItem, java.util.Map<FlowGraph.EdgeKey,DefiniteAssignmentChecker.FlowItem> outItems) Check that the conditions of initialization are not broken.
protected void	checkClassBody(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, ClassBody cb, DefiniteAssignmentChecker.FlowItem dfIn, DefiniteAssignmentChecker.FlowItem 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	checkField(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, Field f, DefiniteAssignmentChecker.FlowItem dfIn) Check that the field f is used correctly.
protected void	checkFieldAssign(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, FieldAssign a, DefiniteAssignmentChecker.FlowItem dfIn) Check that the assignment to a field is correct.
protected void	checkLocal(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, Local l, DefiniteAssignmentChecker.FlowItem dfIn) Check that the local variable l is used correctly.
protected void	checkLocalAssign(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, LocalInstance li, Position pos, DefiniteAssignmentChecker.FlowItem dfIn) Check that the assignment to a local variable is correct.
protected void	checkLocalInstanceInit(LocalInstance li, DefiniteAssignmentChecker.FlowItem dfIn, Position pos)
protected void	checkLocalsUsedByInnerClass(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, ClassBody cb, java.util.Set<LocalInstance> localsUsed, DefiniteAssignmentChecker.FlowItem dfIn, DefiniteAssignmentChecker.FlowItem 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<DefiniteAssignmentChecker.FlowItem> graph, Node n, DefiniteAssignmentChecker.FlowItem dfIn) 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.
DefiniteAssignmentChecker.FlowItem	confluence(java.util.List<DefiniteAssignmentChecker.FlowItem> inItems, FlowGraph.Peer<DefiniteAssignmentChecker.FlowItem> peer, FlowGraph<DefiniteAssignmentChecker.FlowItem> graph) The confluence operator is essentially the union of all of the inItems.
protected DefiniteAssignmentChecker.FlowItem	confluence(java.util.List<DefiniteAssignmentChecker.FlowItem> items, java.util.List<FlowGraph.EdgeKey> itemKeys, FlowGraph.Peer<DefiniteAssignmentChecker.FlowItem> peer, FlowGraph<DefiniteAssignmentChecker.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.
protected CFGBuilder<DefiniteAssignmentChecker.FlowItem>	createCFGBuilder(TypeSystem ts, FlowGraph<DefiniteAssignmentChecker.FlowItem> g) Construct a CFGBuilder.
DefiniteAssignmentChecker.FlowItem	createInitialItem(FlowGraph<DefiniteAssignmentChecker.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<DefiniteAssignmentChecker.FlowItem> graph, ConstructorDecl cd, DefiniteAssignmentChecker.FlowItem dfIn, DefiniteAssignmentChecker.FlowItem dfOut) Perform necessary actions upon seeing the ConstructorDecl cd.
protected void	finishFieldDecl(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, FieldDecl fd, DefiniteAssignmentChecker.FlowItem dfIn, DefiniteAssignmentChecker.FlowItem dfOut) Perform necessary actions upon seeing the FieldDecl fd.
protected void	finishInitializer(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, Initializer initializer, DefiniteAssignmentChecker.FlowItem dfIn, DefiniteAssignmentChecker.FlowItem dfOut) Perform necessary actions upon seeing the Initializer initializer.
java.util.Map<FlowGraph.EdgeKey,DefiniteAssignmentChecker.FlowItem>	flow(DefiniteAssignmentChecker.FlowItem trueItem, DefiniteAssignmentChecker.FlowItem falseItem, DefiniteAssignmentChecker.FlowItem otherItem, FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, FlowGraph.Peer<DefiniteAssignmentChecker.FlowItem> peer) Perform the appropriate flow operations for the Terms.
protected java.util.Map<FlowGraph.EdgeKey,DefiniteAssignmentChecker.FlowItem>	flow(java.util.List<DefiniteAssignmentChecker.FlowItem> inItems, java.util.List<FlowGraph.EdgeKey> inItemKeys, FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, FlowGraph.Peer<DefiniteAssignmentChecker.FlowItem> peer) Produce new Items as appropriate for the peer's node and the input Items.
protected java.util.Map<FlowGraph.EdgeKey,DefiniteAssignmentChecker.FlowItem>	flowConstructorCall(DefiniteAssignmentChecker.FlowItem inItem, FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem>	flowFieldAssign(DefiniteAssignmentChecker.FlowItem inItem, FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem>	flowFormal(DefiniteAssignmentChecker.FlowItem inItem, FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem>	flowLocalAssign(DefiniteAssignmentChecker.FlowItem inItem, FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem>	flowLocalDecl(DefiniteAssignmentChecker.FlowItem inItem, FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem>	flowOther(DefiniteAssignmentChecker.FlowItem inItem, FlowGraph<DefiniteAssignmentChecker.FlowItem> graph, Node n, java.util.Set<FlowGraph.EdgeKey> succEdgeKeys) Allow subclasses to override if necessary.
protected FlowGraph<DefiniteAssignmentChecker.FlowItem>	initGraph(CodeNode code, Term root) Initialize 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, 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 DefiniteAssignmentChecker.ClassBodyInfo currCBI

BOTTOM

protected static final DefiniteAssignmentChecker.FlowItem BOTTOM

Constructor Detail

DefiniteAssignmentChecker

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

Method Detail

initGraph

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

Initialize the FlowGraph to be used in the dataflow analysis.

Overrides:

initGraph in class DataFlow<DefiniteAssignmentChecker.FlowItem>

Returns:

null if no dataflow analysis should be performed for this code declaration; otherwise, an appropriately 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<DefiniteAssignmentChecker.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 DefiniteAssignmentChecker.FlowItem createInitialItem(FlowGraph<DefiniteAssignmentChecker.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<DefiniteAssignmentChecker.FlowItem>

Returns:

a (possibly null) Item.

createCFGBuilder

protected CFGBuilder<DefiniteAssignmentChecker.FlowItem> createCFGBuilder(TypeSystem ts,
                                                              FlowGraph<DefiniteAssignmentChecker.FlowItem> g)

Description copied from class: DataFlow

Construct a CFGBuilder.

Overrides:

createCFGBuilder in class DataFlow<DefiniteAssignmentChecker.FlowItem>

Parameters:

ts - The type system

g - The flow graph to that the CFGBuilder will construct.

Returns:

a new CFGBuilder

confluence

protected DefiniteAssignmentChecker.FlowItem confluence(java.util.List<DefiniteAssignmentChecker.FlowItem> items,
                                            java.util.List<FlowGraph.EdgeKey> itemKeys,
                                            FlowGraph.Peer<DefiniteAssignmentChecker.FlowItem> peer,
                                            FlowGraph<DefiniteAssignmentChecker.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<DefiniteAssignmentChecker.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 DefiniteAssignmentChecker.FlowItem confluence(java.util.List<DefiniteAssignmentChecker.FlowItem> inItems,
                                            FlowGraph.Peer<DefiniteAssignmentChecker.FlowItem> peer,
                                            FlowGraph<DefiniteAssignmentChecker.FlowItem> graph)

The confluence operator is essentially the union of all of the inItems. However, if two or more of the AssignmentStatus maps from the inItems each have a DefiniteAssignments 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<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem> flow(java.util.List<DefiniteAssignmentChecker.FlowItem> inItems,
                                                                       java.util.List<FlowGraph.EdgeKey> inItemKeys,
                                                                       FlowGraph<DefiniteAssignmentChecker.FlowItem> graph,
                                                                       FlowGraph.Peer<DefiniteAssignmentChecker.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<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem> flow(DefiniteAssignmentChecker.FlowItem trueItem,
                                                                       DefiniteAssignmentChecker.FlowItem falseItem,
                                                                       DefiniteAssignmentChecker.FlowItem otherItem,
                                                                       FlowGraph<DefiniteAssignmentChecker.FlowItem> graph,
                                                                       FlowGraph.Peer<DefiniteAssignmentChecker.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 DefiniteAssignment for the LocalInstance. - LocalDecl: a declaration of a local variable, just insert a new DefiniteAssignment 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<DefiniteAssignmentChecker.FlowItem>

flowFormal

protected java.util.Map<FlowGraph.EdgeKey,DefiniteAssignmentChecker.FlowItem> flowFormal(DefiniteAssignmentChecker.FlowItem inItem,
                                                                             FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem> flowLocalDecl(DefiniteAssignmentChecker.FlowItem inItem,
                                                                                FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem> flowLocalAssign(DefiniteAssignmentChecker.FlowItem inItem,
                                                                                  FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem> flowFieldAssign(DefiniteAssignmentChecker.FlowItem inItem,
                                                                                  FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem> flowConstructorCall(DefiniteAssignmentChecker.FlowItem inItem,
                                                                                      FlowGraph<DefiniteAssignmentChecker.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,DefiniteAssignmentChecker.FlowItem> flowOther(DefiniteAssignmentChecker.FlowItem inItem,
                                                                            FlowGraph<DefiniteAssignmentChecker.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<DefiniteAssignmentChecker.FlowItem> graph,
         Term n,
         boolean entry,
         DefiniteAssignmentChecker.FlowItem inItem,
         java.util.Map<FlowGraph.EdgeKey,DefiniteAssignmentChecker.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 DefiniteAssignments to the map currClassFinalFieldInitCounts.

Specified by:

check in class DataFlow<DefiniteAssignmentChecker.FlowItem>

Throws:

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

finishFieldDecl

protected void finishFieldDecl(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph,
                   FieldDecl fd,
                   DefiniteAssignmentChecker.FlowItem dfIn,
                   DefiniteAssignmentChecker.FlowItem dfOut)

Perform necessary actions upon seeing the FieldDecl fd.

finishConstructorDecl

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

Perform necessary actions upon seeing the ConstructorDecl cd.

finishInitializer

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

Perform necessary actions upon seeing the Initializer initializer.

checkField

protected void checkField(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph,
              Field f,
              DefiniteAssignmentChecker.FlowItem dfIn)
                   throws SemanticException

Check that the field f is used correctly. See JLS 2nd Ed. | 16: Every blank final field must have a definitely assigned value when any access of its value occurs.

Throws:

SemanticException

checkLocal

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

Check that the local variable l is used correctly.

Throws:

SemanticException

checkLocalInstanceInit

protected void checkLocalInstanceInit(LocalInstance li,
                          DefiniteAssignmentChecker.FlowItem dfIn,
                          Position pos)
                               throws SemanticException

Throws:

SemanticException

checkLocalAssign

protected void checkLocalAssign(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph,
                    LocalInstance li,
                    Position pos,
                    DefiniteAssignmentChecker.FlowItem dfIn)
                         throws SemanticException

Check that the assignment to a local variable is correct.

Throws:

SemanticException

checkFieldAssign

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

Check that the assignment to a field is correct.

Throws:

SemanticException

checkClassBody

protected void checkClassBody(FlowGraph<DefiniteAssignmentChecker.FlowItem> graph,
                  ClassBody cb,
                  DefiniteAssignmentChecker.FlowItem dfIn,
                  DefiniteAssignmentChecker.FlowItem 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<DefiniteAssignmentChecker.FlowItem> graph,
                               ClassBody cb,
                               java.util.Set<LocalInstance> localsUsed,
                               DefiniteAssignmentChecker.FlowItem dfIn,
                               DefiniteAssignmentChecker.FlowItem 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<DefiniteAssignmentChecker.FlowItem> graph,
              Node n,
              DefiniteAssignmentChecker.FlowItem dfIn)
                   throws SemanticException

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

Throws:

SemanticException