accrue.analysis.defuse

## Class DefUseDataFlow

- java.lang.Object
- - polyglot.visit.NodeVisitor
  - - polyglot.visit.HaltingVisitor
    - - polyglot.visit.ErrorHandlingVisitor
      - - polyglot.visit.DataFlow<FlowItem>
        - - accrue.analysis.interprocanalysis.PreciseDataFlow<VarContext<T>>
          - - accrue.analysis.interprocvarcontext.VarContextDataFlow<DefUseAbsVal>
            - - accrue.analysis.defuse.DefUseDataFlow

- All Implemented Interfaces:
    DataFlowDispatch<VarContext<DefUseAbsVal>>, java.lang.Cloneable, polyglot.util.Copy<polyglot.visit.NodeVisitor>

      public class DefUseDataFlow
      extends VarContextDataFlow<DefUseAbsVal>

  This dataflow finds reaching definitions for each local and field use.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class accrue.analysis.interprocanalysis.PreciseDataFlow

      `PreciseDataFlow.PreciseCFGBuilder<FlowItem extends polyglot.visit.DataFlow.Item>`

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

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

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

      `polyglot.util.Copy.Util`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected java.util.Set<AbstractLocation>` | `aUnitDefs`
    `protected java.util.Set<AbstractLocation>` | `aUnitObs`
    `protected java.util.Set<EdgeIdentifier>` | `aUnitUses`
    `protected DefUseAnalysisUtil` | `autil`
    `protected java.lang.String` | `data_dep_results_key`
    `protected boolean` | `heap_assign_is_use` Treat heap assignments as uses of the left-hand side.
    `protected java.util.Map<DataFlowNodeIdentifier,java.lang.Integer>` | `nodePostordering`

    - ### Fields inherited from class accrue.analysis.interprocvarcontext.VarContextDataFlow

      `DONT_TRACK_BOTTOM, output, WARN_ON_MISSING_EDGES, workQueue`

    - ### 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
    `DefUseDataFlow(DefUseAnalysisUtil autil, WorkQueue<VarContext<DefUseAbsVal>> workQueue, polyglot.frontend.Job job, polyglot.types.TypeSystem ts, polyglot.ast.NodeFactory nf)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <T> void` | `addResults(java.lang.String resultKey, AccrueExt rec, AnalysisContext ctx, java.util.Set<T> results)` Adds a set of results to the current set
    `protected void` | `check(polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> p)`
    `protected void` | `check(polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.ast.Term n, boolean entry, VarContext<DefUseAbsVal> inItem, java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> outItems)`
    `protected DefUseAbsVal` | `createHeapDefinition(java.util.Set<AbstractLocation> locs, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `protected DefUseAbsVal` | `createLocalDefinition(java.lang.String defined, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `protected FinalVarContext<DefUseAbsVal>` | `flowArithmeticException(VarContext<DefUseAbsVal> dfIn, polyglot.ast.Binary cause, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowArrayAccess(polyglot.ast.ArrayAccess n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowArrayAccessAssign(polyglot.ast.ArrayAccessAssign n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowArrayInit(polyglot.ast.ArrayInit n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowBinary(polyglot.ast.Binary n, VarContext<DefUseAbsVal> dfIn, VarContext<DefUseAbsVal> trueItem, VarContext<DefUseAbsVal> falseItem, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowCall(polyglot.ast.Call n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowCast(polyglot.ast.Cast n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowCatch(polyglot.ast.Catch n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `protected FinalVarContext<DefUseAbsVal>` | `flowClassCastException(VarContext<DefUseAbsVal> dfIn, polyglot.ast.Cast cause, DefUseAbsVal causeDFI, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowCodeDecl(polyglot.ast.CodeDecl n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowConstructorCall(polyglot.ast.ConstructorCall n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowExpr(polyglot.ast.Expr n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowField(polyglot.ast.Field n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowFieldAssign(polyglot.ast.FieldAssign n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowFieldDecl(polyglot.ast.FieldDecl n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowFinally(polyglot.ast.Block n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowFormal(polyglot.ast.Formal n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowIf(polyglot.ast.If n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `protected java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowImpl(VarContext<DefUseAbsVal> trueItem, VarContext<DefUseAbsVal> falseItem, VarContext<DefUseAbsVal> otherItem, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `protected FinalVarContext<DefUseAbsVal>` | `flowImpossibleException(FinalVarContext<DefUseAbsVal> res, polyglot.types.ClassType exType, polyglot.ast.Node cause)`
    `protected FinalVarContext<DefUseAbsVal>` | `flowImpossibleException(VarContext<DefUseAbsVal> dfIn, polyglot.types.ClassType exType, polyglot.ast.Node cause, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowInstanceof(polyglot.ast.Instanceof n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowLit(polyglot.ast.Lit n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowLocal(polyglot.ast.Local n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowLocalAssign(polyglot.ast.LocalAssign n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowLocalDecl(polyglot.ast.LocalDecl n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowNew(polyglot.ast.New n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowNewArray(polyglot.ast.NewArray n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `protected FinalVarContext<DefUseAbsVal>` | `flowNullPointerException(VarContext<DefUseAbsVal> dfIn, polyglot.ast.Node cause, DefUseAbsVal causeDFI, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `protected FinalVarContext<DefUseAbsVal>` | `flowOutOfBoundsException(VarContext<DefUseAbsVal> dfIn, polyglot.ast.Expr cause, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowReturn(polyglot.ast.Return n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowSpecial(polyglot.ast.Special n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowStmt(polyglot.ast.Stmt n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowThrow(polyglot.ast.Throw n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowTry(polyglot.ast.Try n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowTypeNode(polyglot.ast.TypeNode n, VarContext<DefUseAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `flowUnary(polyglot.ast.Unary n, VarContext<DefUseAbsVal> dfIn, VarContext<DefUseAbsVal> trueItem, VarContext<DefUseAbsVal> falseItem, polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)` Compute the dataflow for `n`
    `protected FinalVarContext<DefUseAbsVal>` | `flowUncheckedException(VarContext<DefUseAbsVal> dfIn, polyglot.types.ClassType exType, polyglot.ast.Node cause, polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)`
    `protected static java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>>` | `itemToMapWithExceptionResults(VarContext<DefUseAbsVal> dfIn, java.util.Set<polyglot.visit.FlowGraph.EdgeKey> edgeKeys)`
    `protected int` | `postorderNodeIDs(polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> p, int count, java.util.Set<NodeIdentifier> visited)`
    `protected DefUseAbsVal` | `upperBound(java.util.Collection<DefUseAbsVal> l)`

    - ### Methods inherited from class accrue.analysis.interprocvarcontext.VarContextDataFlow

      `argumentsOnResultStack, autil, checkInvariants, confluence, constructMissingContextForEdgeKey, createInitialItem, dataflow, edgeKeyConvert, finalVarContextToDataFlowMap, flow, flow, flowAssert, flowAssign, flowBlock, flowBranch, flowConditional, flowConstructorDecl, flowDo, flowEmpty, flowEval, flowInitializer, flowLabeled, flowMethodDecl, flowSuppress, flowSynchronized, flowWhile, ignoreNode, keyConvert, post, postFieldDecl, safeConfluence, setWarnOnEdgesMissingData`

    - ### Methods inherited from class accrue.analysis.interprocanalysis.PreciseDataFlow

      `createCFGBuilder, currentContext, dataFlowNodeIdentifierForPeer, dataFlowNodeIdentifierForPeer, initGraph, peerForDataFlowNodeIdentifier`

    - ### Methods inherited from class polyglot.visit.DataFlow

      `confluence, 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, leaveCall, safeConfluence, safeConfluence`

    - ### Methods inherited from class polyglot.visit.ErrorHandlingVisitor

      `begin, catchErrors, enter, enterCall, 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

    - #### autil

          protected final DefUseAnalysisUtil autil

    - #### aUnitUses

          protected final java.util.Set<EdgeIdentifier> aUnitUses

    - #### aUnitObs

          protected final java.util.Set<AbstractLocation> aUnitObs

    - #### aUnitDefs

          protected final java.util.Set<AbstractLocation> aUnitDefs

    - #### heap_assign_is_use

          protected final boolean heap_assign_is_use

      Treat heap assignments as uses of the left-hand side.
      See Also:
        Constant Field Values

    - #### data_dep_results_key

          protected final java.lang.String data_dep_results_key

    - #### nodePostordering

          protected java.util.Map<DataFlowNodeIdentifier,java.lang.Integer> nodePostordering

  - ### Constructor Detail

    - #### DefUseDataFlow

          public DefUseDataFlow(DefUseAnalysisUtil autil,
                        WorkQueue<VarContext<DefUseAbsVal>> workQueue,
                        polyglot.frontend.Job job,
                        polyglot.types.TypeSystem ts,
                        polyglot.ast.NodeFactory nf)

  - ### Method Detail

    - #### addResults

          public static <T> void addResults(java.lang.String resultKey,
                            AccrueExt rec,
                            AnalysisContext ctx,
                            java.util.Set<T> results)

      Adds a set of results to the current set
      Parameters:
        `resultKey` - The key of the analysis result to record.
        `rec` - The extension object to record these results on.
        `ctx` - The AnalysisContext to associate these results with.
        `results` -

    - #### postorderNodeIDs

          protected int postorderNodeIDs(polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> p,
                             int count,
                             java.util.Set<NodeIdentifier> visited)

    - #### check

          protected void check(polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                   polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> p)
                        throws polyglot.types.SemanticException

      Overrides:
        `check` in class `polyglot.visit.DataFlow<VarContext<DefUseAbsVal>>`
      Throws:
        `polyglot.types.SemanticException`

    - #### flowImpl

          protected java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowImpl(VarContext<DefUseAbsVal> trueItem,
                                                                                          VarContext<DefUseAbsVal> falseItem,
                                                                                          VarContext<DefUseAbsVal> otherItem,
                                                                                          polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Specified by:
        `flowImpl` in class `VarContextDataFlow<DefUseAbsVal>`

    - #### check

          protected void check(polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                   polyglot.ast.Term n,
                   boolean entry,
                   VarContext<DefUseAbsVal> inItem,
                   java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> outItems)
                        throws polyglot.types.SemanticException

      Specified by:
        `check` in class `polyglot.visit.DataFlow<VarContext<DefUseAbsVal>>`
      Throws:
        `polyglot.types.SemanticException`

    - #### flowCodeDecl

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowCodeDecl(polyglot.ast.CodeDecl n,
                                                                                              VarContext<DefUseAbsVal> dfIn,
                                                                                              polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                              polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from class: `VarContextDataFlow`
      Compute the dataflow for `n`
      Overrides:
        `flowCodeDecl` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowLocalDecl

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowLocalDecl(polyglot.ast.LocalDecl n,
                                                                                               VarContext<DefUseAbsVal> dfIn,
                                                                                               polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                               polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLocalDecl` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowLocalDecl` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowFormal

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowFormal(polyglot.ast.Formal n,
                                                                                            VarContext<DefUseAbsVal> dfIn,
                                                                                            polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                            polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFormal` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowFormal` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowLocal

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowLocal(polyglot.ast.Local n,
                                                                                           VarContext<DefUseAbsVal> dfIn,
                                                                                           polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                           polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLocal` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowLocal` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowLocalAssign

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowLocalAssign(polyglot.ast.LocalAssign n,
                                                                                                 VarContext<DefUseAbsVal> dfIn,
                                                                                                 polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLocalAssign` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowLocalAssign` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowField

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowField(polyglot.ast.Field n,
                                                                                           VarContext<DefUseAbsVal> dfIn,
                                                                                           polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                           polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowField` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowField` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowFieldDecl

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowFieldDecl(polyglot.ast.FieldDecl n,
                                                                                               VarContext<DefUseAbsVal> dfIn,
                                                                                               polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                               polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFieldDecl` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowFieldDecl` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowFieldAssign

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowFieldAssign(polyglot.ast.FieldAssign n,
                                                                                                 VarContext<DefUseAbsVal> dfIn,
                                                                                                 polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFieldAssign` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowFieldAssign` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowArrayAccess

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowArrayAccess(polyglot.ast.ArrayAccess n,
                                                                                                 VarContext<DefUseAbsVal> dfIn,
                                                                                                 polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayAccess` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowArrayAccess` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurrence of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowArrayAccessAssign

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowArrayAccessAssign(polyglot.ast.ArrayAccessAssign n,
                                                                                                       VarContext<DefUseAbsVal> dfIn,
                                                                                                       polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                                       polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayAccessAssign` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowArrayAccessAssign` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowArrayInit

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowArrayInit(polyglot.ast.ArrayInit n,
                                                                                               VarContext<DefUseAbsVal> dfIn,
                                                                                               polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                               polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayInit` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowArrayInit` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowNewArray

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowNewArray(polyglot.ast.NewArray n,
                                                                                              VarContext<DefUseAbsVal> dfIn,
                                                                                              polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                              polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowNewArray` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowNewArray` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowCall

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowCall(polyglot.ast.Call n,
                                                                                          VarContext<DefUseAbsVal> dfIn,
                                                                                          polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowCall` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowCall` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowNew

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowNew(polyglot.ast.New n,
                                                                                         VarContext<DefUseAbsVal> dfIn,
                                                                                         polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                         polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowNew` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowNew` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowConstructorCall

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowConstructorCall(polyglot.ast.ConstructorCall n,
                                                                                                     VarContext<DefUseAbsVal> dfIn,
                                                                                                     polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                                     polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowConstructorCall` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowConstructorCall` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowThrow

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowThrow(polyglot.ast.Throw n,
                                                                                           VarContext<DefUseAbsVal> dfIn,
                                                                                           polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                           polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowThrow` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowThrow` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowReturn

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowReturn(polyglot.ast.Return n,
                                                                                            VarContext<DefUseAbsVal> dfIn,
                                                                                            polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                            polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowReturn` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowReturn` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowExpr

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowExpr(polyglot.ast.Expr n,
                                                                                          VarContext<DefUseAbsVal> dfIn,
                                                                                          polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowExpr` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowExpr` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowCast

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowCast(polyglot.ast.Cast n,
                                                                                          VarContext<DefUseAbsVal> dfIn,
                                                                                          polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowCast` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowCast` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowBinary

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowBinary(polyglot.ast.Binary n,
                                                                                            VarContext<DefUseAbsVal> dfIn,
                                                                                            VarContext<DefUseAbsVal> trueItem,
                                                                                            VarContext<DefUseAbsVal> falseItem,
                                                                                            polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                            polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowBinary` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowBinary` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowSpecial

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowSpecial(polyglot.ast.Special n,
                                                                                             VarContext<DefUseAbsVal> dfIn,
                                                                                             polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                             polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowSpecial` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowSpecial` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowLit

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowLit(polyglot.ast.Lit n,
                                                                                         VarContext<DefUseAbsVal> dfIn,
                                                                                         polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                         polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLit` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowLit` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowInstanceof

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowInstanceof(polyglot.ast.Instanceof n,
                                                                                                VarContext<DefUseAbsVal> dfIn,
                                                                                                polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                                polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowInstanceof` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowInstanceof` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowUnary

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowUnary(polyglot.ast.Unary n,
                                                                                           VarContext<DefUseAbsVal> dfIn,
                                                                                           VarContext<DefUseAbsVal> trueItem,
                                                                                           VarContext<DefUseAbsVal> falseItem,
                                                                                           polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                           polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowUnary` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowUnary` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowStmt

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowStmt(polyglot.ast.Stmt n,
                                                                                          VarContext<DefUseAbsVal> dfIn,
                                                                                          polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from class: `VarContextDataFlow`
      Compute the dataflow for `n`
      Overrides:
        `flowStmt` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowFinally

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowFinally(polyglot.ast.Block n,
                                                                                             VarContext<DefUseAbsVal> dfIn,
                                                                                             polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                             polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFinally` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowFinally` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowTypeNode

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowTypeNode(polyglot.ast.TypeNode n,
                                                                                              VarContext<DefUseAbsVal> dfIn,
                                                                                              polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                              polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowTypeNode` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowTypeNode` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowTry

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowTry(polyglot.ast.Try n,
                                                                                         VarContext<DefUseAbsVal> dfIn,
                                                                                         polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                         polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowTry` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowTry` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowCatch

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowCatch(polyglot.ast.Catch n,
                                                                                           VarContext<DefUseAbsVal> dfIn,
                                                                                           polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                           polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowCatch` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowCatch` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowIf

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> flowIf(polyglot.ast.If n,
                                                                                        VarContext<DefUseAbsVal> dfIn,
                                                                                        polyglot.visit.FlowGraph<VarContext<DefUseAbsVal>> graph,
                                                                                        polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowIf` in interface `DataFlowDispatch<VarContext<DefUseAbsVal>>`
      Overrides:
        `flowIf` in class `VarContextDataFlow<DefUseAbsVal>`
      Parameters:
        `n` - AST node to compute the dataflow for
        `dfIn` - input dataflow item
        `graph` - dataflow graph
        `peer` - occurance of the dataflow node in the flowgraph
      Returns:
        A map of exit edge keys to dataflow items

    - #### flowUncheckedException

          protected FinalVarContext<DefUseAbsVal> flowUncheckedException(VarContext<DefUseAbsVal> dfIn,
                                                             polyglot.types.ClassType exType,
                                                             polyglot.ast.Node cause,
                                                             polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### flowImpossibleException

          protected FinalVarContext<DefUseAbsVal> flowImpossibleException(VarContext<DefUseAbsVal> dfIn,
                                                              polyglot.types.ClassType exType,
                                                              polyglot.ast.Node cause,
                                                              polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### flowImpossibleException

          protected FinalVarContext<DefUseAbsVal> flowImpossibleException(FinalVarContext<DefUseAbsVal> res,
                                                              polyglot.types.ClassType exType,
                                                              polyglot.ast.Node cause)

    - #### flowNullPointerException

          protected FinalVarContext<DefUseAbsVal> flowNullPointerException(VarContext<DefUseAbsVal> dfIn,
                                                               polyglot.ast.Node cause,
                                                               DefUseAbsVal causeDFI,
                                                               polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### flowArithmeticException

          protected FinalVarContext<DefUseAbsVal> flowArithmeticException(VarContext<DefUseAbsVal> dfIn,
                                                              polyglot.ast.Binary cause,
                                                              polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### flowOutOfBoundsException

          protected FinalVarContext<DefUseAbsVal> flowOutOfBoundsException(VarContext<DefUseAbsVal> dfIn,
                                                               polyglot.ast.Expr cause,
                                                               polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### flowClassCastException

          protected FinalVarContext<DefUseAbsVal> flowClassCastException(VarContext<DefUseAbsVal> dfIn,
                                                             polyglot.ast.Cast cause,
                                                             DefUseAbsVal causeDFI,
                                                             polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### upperBound

          protected DefUseAbsVal upperBound(java.util.Collection<DefUseAbsVal> l)

    - #### createLocalDefinition

          protected DefUseAbsVal createLocalDefinition(java.lang.String defined,
                                           polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### createHeapDefinition

          protected DefUseAbsVal createHeapDefinition(java.util.Set<AbstractLocation> locs,
                                          polyglot.visit.FlowGraph.Peer<VarContext<DefUseAbsVal>> peer)

    - #### itemToMapWithExceptionResults

          protected static java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<DefUseAbsVal>> itemToMapWithExceptionResults(VarContext<DefUseAbsVal> dfIn,
                                                                                                               java.util.Set<polyglot.visit.FlowGraph.EdgeKey> edgeKeys)