accrue.analysis.interprocvarcontext

## Class VarContextDataFlow<T extends AbstractValue<T>>

- 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<T>

- Type Parameters:
    `A` - Defines the lattice for procedure summaries
    `T` - Type that is used for the variable context
  All Implemented Interfaces:
    DataFlowDispatch<VarContext<T>>, java.lang.Cloneable, polyglot.util.Copy<polyglot.visit.NodeVisitor>
  Direct Known Subclasses:
    AntiDepDataFlow, DefUseDataFlow, NotNullDataFlow

      public abstract class VarContextDataFlow<T extends AbstractValue<T>>
      extends PreciseDataFlow<VarContext<T>>
      implements DataFlowDispatch<VarContext<T>>

  Add support for analysis contexts. When you get to a function determine whether the function has been analyzed in that context; if not adds to work queue.

- - ### 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
    --- | ---
    `static boolean` | `DONT_TRACK_BOTTOM` Change this if we want bottom policies to stick around
    `protected FinalVarContext<T>` | `output` output variable context
    `static boolean` | `WARN_ON_MISSING_EDGES` Determines whether to warn on missing dataflow edges
    `protected WorkQueue<?>` | `workQueue` Analysis work queue

    - ### 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
    `VarContextDataFlow(AnalysisUtilVarContextDataFlow<?,T> autil, WorkQueue<?> workQueue, polyglot.frontend.Job job, polyglot.types.TypeSystem ts, polyglot.ast.NodeFactory nf, boolean forward)` Create a new dataflow visitor
    `VarContextDataFlow(AnalysisUtilVarContextDataFlow<?,T> autil, WorkQueue<?> workQueue, polyglot.frontend.Job job, polyglot.types.TypeSystem ts, polyglot.ast.NodeFactory nf, boolean forward, boolean dataflowOnEntry, boolean trackBackEdges)` Create a new dataflow visitor

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected static <T extends AbstractValue<T>> int` | `argumentsOnResultStack(polyglot.ast.Term t, VarContext<T> vc)` Get the number of argument results on the stack
    `protected AnalysisUtilVarContextDataFlow<?,T>` | `autil()`
    `protected void` | `checkInvariants(java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> m, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Check that our dataflow invariants hold
    `protected VarContext<T>` | `confluence(java.util.List<VarContext<T>> items, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer, polyglot.visit.FlowGraph<VarContext<T>> graph)`
    `protected VarContext<T>` | `constructMissingContextForEdgeKey(polyglot.visit.FlowGraph.EdgeKey ek, FinalVarContext<T> f, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` If an edge is missing this method is called to approximate the variable context
    `protected VarContext<T>` | `createInitialItem(polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.ast.Term node, boolean entry)` Create an initial Item for the dataflow analysis.
    `FinalVarContext<T>` | `dataflow(polyglot.ast.CodeNode cd, VarContext<T> in)` Construct a graph for the given code and call super `DataFlow.dataflow(FlowGraph)` on it
    `static ExitMap.Key` | `edgeKeyConvert(polyglot.visit.FlowGraph.EdgeKey ek)` Convert `FlowGraph` edge keys to `FinalVarContext` edge keys
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `finalVarContextToDataFlowMap(FinalVarContext<T> f, java.util.Set<polyglot.visit.FlowGraph.EdgeKey> succEdgeKeys, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Converts a FinalVarContext to a map from EdgeKeys to Items.
    `protected java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flow(java.util.List<VarContext<T>> inItems, java.util.List<polyglot.visit.FlowGraph.EdgeKey> inItemKeys, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flow(VarContext<T> trueItem, VarContext<T> falseItem, VarContext<T> otherItem, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Produce new variable contexts from the input contexts and `FlowGraph.Peer`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowArrayAccess(polyglot.ast.ArrayAccess n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowArrayAccessAssign(polyglot.ast.ArrayAccessAssign n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowArrayInit(polyglot.ast.ArrayInit n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowAssert(polyglot.ast.Assert n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowAssign(polyglot.ast.Assign n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowBinary(polyglot.ast.Binary n, VarContext<T> dfIn, VarContext<T> trueItem, VarContext<T> falseItem, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowBlock(polyglot.ast.Block n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowBranch(polyglot.ast.Branch n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowCall(polyglot.ast.Call n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowCast(polyglot.ast.Cast n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowCatch(polyglot.ast.Catch n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowCodeDecl(polyglot.ast.CodeDecl n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowConditional(polyglot.ast.Conditional n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowConstructorCall(polyglot.ast.ConstructorCall n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowConstructorDecl(polyglot.ast.ConstructorDecl n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowDo(polyglot.ast.Do n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowEmpty(polyglot.ast.Empty n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowEval(polyglot.ast.Eval n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowExpr(polyglot.ast.Expr n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowField(polyglot.ast.Field n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowFieldAssign(polyglot.ast.FieldAssign n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowFieldDecl(polyglot.ast.FieldDecl n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowFinally(polyglot.ast.Block n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowFormal(polyglot.ast.Formal n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowIf(polyglot.ast.If n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `protected abstract java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowImpl(VarContext<T> trueItem, VarContext<T> falseItem, VarContext<T> otherItem, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowInitializer(polyglot.ast.Initializer n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowInstanceof(polyglot.ast.Instanceof n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowLabeled(polyglot.ast.Labeled n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowLit(polyglot.ast.Lit n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowLocal(polyglot.ast.Local n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowLocalAssign(polyglot.ast.LocalAssign n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowLocalDecl(polyglot.ast.LocalDecl n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowMethodDecl(polyglot.ast.MethodDecl n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowNew(polyglot.ast.New n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowNewArray(polyglot.ast.NewArray n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowReturn(polyglot.ast.Return n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowSpecial(polyglot.ast.Special n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowStmt(polyglot.ast.Stmt n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowSuppress(Suppress n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowSynchronized(polyglot.ast.Synchronized n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowThrow(polyglot.ast.Throw n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowTry(polyglot.ast.Try n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowTypeNode(polyglot.ast.TypeNode n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowUnary(polyglot.ast.Unary n, VarContext<T> dfIn, VarContext<T> trueItem, VarContext<T> falseItem, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `flowWhile(polyglot.ast.While n, VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>>` | `ignoreNode(VarContext<T> dfIn, polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)` Ignore the node (i.e., it is a no-op).
    `protected static polyglot.visit.FlowGraph.EdgeKey` | `keyConvert(ExitMap.Key k)` Convert `FinalVarContext` edge keys to `FlowGraph` edge keys
    `protected void` | `post(polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.ast.Term root)`
    `protected void` | `postFieldDecl(polyglot.visit.FlowGraph<VarContext<T>> graph, polyglot.visit.FlowGraph.Peer<VarContext<T>> p)` Handle the post-processing for a finish peer for a FieldDecl specially.
    `protected VarContext<T>` | `safeConfluence(java.util.List<VarContext<T>> items, java.util.List<polyglot.visit.FlowGraph.EdgeKey> itemKeys, polyglot.visit.FlowGraph.Peer<VarContext<T>> peer, polyglot.visit.FlowGraph<VarContext<T>> graph)`
    `protected void` | `setWarnOnEdgesMissingData(boolean warn)` Set whether to warn on missing dataflow edges

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

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

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

      `check, check, 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

    - #### DONT_TRACK_BOTTOM

          public static final boolean DONT_TRACK_BOTTOM

      Change this if we want bottom policies to stick around
      See Also:
        Constant Field Values

    - #### WARN_ON_MISSING_EDGES

          public static boolean WARN_ON_MISSING_EDGES

      Determines whether to warn on missing dataflow edges

    - #### workQueue

          protected final WorkQueue<?> workQueue

      Analysis work queue

    - #### output

          protected FinalVarContext<T extends AbstractValue<T>> output

      output variable context

  - ### Constructor Detail

    - #### VarContextDataFlow

          public VarContextDataFlow(AnalysisUtilVarContextDataFlow<?,T> autil,
                            WorkQueue<?> workQueue,
                            polyglot.frontend.Job job,
                            polyglot.types.TypeSystem ts,
                            polyglot.ast.NodeFactory nf,
                            boolean forward)

      Create a new dataflow visitor
      Parameters:
        `autil` - Analysis helper class
        `workQueue` - Analysis work queue
        `job` - Polyglot compiler `Job`
        `ts` - Polyglot type system
        `nf` - factory for creating AST nodes
        `forward` - forward or backward dataflow

    - #### VarContextDataFlow

          public VarContextDataFlow(AnalysisUtilVarContextDataFlow<?,T> autil,
                            WorkQueue<?> workQueue,
                            polyglot.frontend.Job job,
                            polyglot.types.TypeSystem ts,
                            polyglot.ast.NodeFactory nf,
                            boolean forward,
                            boolean dataflowOnEntry,
                            boolean trackBackEdges)

      Create a new dataflow visitor
      Parameters:
        `autil` - Analysis helper class
        `workQueue` - Analysis work queue
        `job` - Polyglot compiler `Job`
        `ts` - Polyglot type system
        `nf` - factory for creating AST nodes
        `forward` - forward or backward dataflow
        `dataflowOnEntry` - true if we want to process the entry node
        `trackBackEdges` - true if the dataflow tracks backward FlowGraph> edges

  - ### Method Detail

    - #### autil

          protected AnalysisUtilVarContextDataFlow<?,T> autil()

      Overrides:
        `autil` in class `PreciseDataFlow<VarContext<T extends AbstractValue<T>>>`
      Returns:
        the analysis helper class

    - #### createInitialItem

          protected VarContext<T> createInitialItem(polyglot.visit.FlowGraph<VarContext<T>> graph,
                                        polyglot.ast.Term node,
                                        boolean entry)

      Create an initial Item for the dataflow analysis. By default, the set of not null variables is empty.
      Specified by:
        `createInitialItem` in class `polyglot.visit.DataFlow<VarContext<T extends AbstractValue<T>>>`

    - #### dataflow

          public FinalVarContext<T> dataflow(polyglot.ast.CodeNode cd,
                                    VarContext<T> in)
                                                               throws polyglot.types.SemanticException

      Construct a graph for the given code and call super `DataFlow.dataflow(FlowGraph)` on it
      Parameters:
        `cd` - Code to flow
        `in` - initial variable context
      Returns:
        variable context after analyzing the FlowGraph> for `cd`
      Throws:
        `polyglot.types.SemanticException` - thrown on an analysis error

    - #### flow

          protected final java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flow(java.util.List<VarContext<T>> inItems,
                                                                           java.util.List<polyglot.visit.FlowGraph.EdgeKey> inItemKeys,
                                                                           polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                           polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Overrides:
        `flow` in class `polyglot.visit.DataFlow<VarContext<T extends AbstractValue<T>>>`

    - #### flow

          public final java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flow(VarContext<T> trueItem,
                                                                           VarContext<T> falseItem,
                                                                           VarContext<T> otherItem,
                                                                           polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                           polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Produce new variable contexts from the input contexts and `FlowGraph.Peer`
      Overrides:
        `flow` in class `polyglot.visit.DataFlow<VarContext<T extends AbstractValue<T>>>`
      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
        `peer` - the Peer> which this method must calculate the flow for.
      Returns:
        Map of exit keys to variable contexts

    - #### checkInvariants

          protected void checkInvariants(java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> m,
                             polyglot.visit.FlowGraph<VarContext<T>> graph,
                             polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Check that our dataflow invariants hold
      Parameters:
        `m` - map holding the variable context for each exit path
        `graph` - the FlowGraph> which the dataflow is operating on
        `peer` - the Peer> which this method must check invariants for.

    - #### safeConfluence

          protected VarContext<T> safeConfluence(java.util.List<VarContext<T>> items,
                                     java.util.List<polyglot.visit.FlowGraph.EdgeKey> itemKeys,
                                     polyglot.visit.FlowGraph.Peer<VarContext<T>> peer,
                                     polyglot.visit.FlowGraph<VarContext<T>> graph)

      Overrides:
        `safeConfluence` in class `polyglot.visit.DataFlow<VarContext<T extends AbstractValue<T>>>`

    - #### confluence

          protected VarContext<T> confluence(java.util.List<VarContext<T>> items,
                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer,
                                 polyglot.visit.FlowGraph<VarContext<T>> graph)

      Specified by:
        `confluence` in class `polyglot.visit.DataFlow<VarContext<T extends AbstractValue<T>>>`

    - #### flowImpl

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

    - #### post

          protected void post(polyglot.visit.FlowGraph<VarContext<T>> graph,
                  polyglot.ast.Term root)
                       throws polyglot.types.SemanticException

      Overrides:
        `post` in class `polyglot.visit.DataFlow<VarContext<T extends AbstractValue<T>>>`
      Throws:
        `polyglot.types.SemanticException`

    - #### postFieldDecl

          protected void postFieldDecl(polyglot.visit.FlowGraph<VarContext<T>> graph,
                           polyglot.visit.FlowGraph.Peer<VarContext<T>> p)

      Handle the post-processing for a finish peer for a FieldDecl specially. This method updates the field output appropriately for the finish peer.
      Parameters:
        `graph` -
        `p` -

    - #### edgeKeyConvert

          public static ExitMap.Key edgeKeyConvert(polyglot.visit.FlowGraph.EdgeKey ek)

      Convert `FlowGraph` edge keys to `FinalVarContext` edge keys
      Parameters:
        `ek` - `FlowGraph` key to convert
      Returns:
        `FinalVarContext` edge key

    - #### keyConvert

          protected static polyglot.visit.FlowGraph.EdgeKey keyConvert(ExitMap.Key k)

      Convert `FinalVarContext` edge keys to `FlowGraph` edge keys
      Parameters:
        `ek` - `FinalVarContext` key to convert
      Returns:
        `FlowGraph` edge key

    - #### finalVarContextToDataFlowMap

          public final java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> finalVarContextToDataFlowMap(FinalVarContext<T> f,
                                                                                                   java.util.Set<polyglot.visit.FlowGraph.EdgeKey> succEdgeKeys,
                                                                                                   polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Converts a FinalVarContext to a map from EdgeKeys to Items. This makes an effort to produce a map that contains all and only keys in succEdgeKeys
      Parameters:
        `f` - variable context to convert
        `succEdgeKeys` - edge keys to retain
        `node` - AST node where this is called (used for debugging)

    - #### setWarnOnEdgesMissingData

          protected void setWarnOnEdgesMissingData(boolean warn)

      Set whether to warn on missing dataflow edges
      Parameters:
        `warn` -

    - #### constructMissingContextForEdgeKey

          protected VarContext<T> constructMissingContextForEdgeKey(polyglot.visit.FlowGraph.EdgeKey ek,
                                                        FinalVarContext<T> f,
                                                        polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      If an edge is missing this method is called to approximate the variable context
      Parameters:
        `ek` - edge key of missing edge
        `f` - the finalVarContext that we were using.
      Returns:
        variable context

    - #### argumentsOnResultStack

          protected static <T extends AbstractValue<T>> int argumentsOnResultStack(polyglot.ast.Term t,
                                                                VarContext<T> vc)

      Get the number of argument results on the stack
      Parameters:
        `t` - AST node to compute the number of arguments for
      Returns:
        number of argument results on the stack for `t`

    - #### flowField

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowField` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowReturn(polyglot.ast.Return n,
                                                                                 VarContext<T> dfIn,
                                                                                 polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowReturn` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowAssert

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowAssert(polyglot.ast.Assert n,
                                                                                 VarContext<T> dfIn,
                                                                                 polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowAssert` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowThrow(polyglot.ast.Throw n,
                                                                                VarContext<T> dfIn,
                                                                                polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowThrow` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowConditional

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowConditional(polyglot.ast.Conditional n,
                                                                                      VarContext<T> dfIn,
                                                                                      polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                      polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowConditional` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowCall(polyglot.ast.Call n,
                                                                               VarContext<T> dfIn,
                                                                               polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                               polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowCall` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowNew(polyglot.ast.New n,
                                                                              VarContext<T> dfIn,
                                                                              polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                              polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowNew` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowNewArray(polyglot.ast.NewArray n,
                                                                                   VarContext<T> dfIn,
                                                                                   polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                   polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowNewArray` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowConstructorCall(polyglot.ast.ConstructorCall n,
                                                                                          VarContext<T> dfIn,
                                                                                          polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowConstructorCall` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowUnary(polyglot.ast.Unary n,
                                                                                VarContext<T> dfIn,
                                                                                VarContext<T> trueItem,
                                                                                VarContext<T> falseItem,
                                                                                polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowUnary` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowBinary(polyglot.ast.Binary n,
                                                                                 VarContext<T> dfIn,
                                                                                 VarContext<T> trueItem,
                                                                                 VarContext<T> falseItem,
                                                                                 polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowBinary` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowAssign

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowAssign(polyglot.ast.Assign n,
                                                                                 VarContext<T> dfIn,
                                                                                 polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Compute the dataflow for `n`
      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<T>> flowTypeNode(polyglot.ast.TypeNode n,
                                                                                   VarContext<T> dfIn,
                                                                                   polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                   polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowTypeNode` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowInstanceof(polyglot.ast.Instanceof n,
                                                                                     VarContext<T> dfIn,
                                                                                     polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                     polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowInstanceof` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowCast(polyglot.ast.Cast n,
                                                                               VarContext<T> dfIn,
                                                                               polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                               polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowCast` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowLocalDecl(polyglot.ast.LocalDecl n,
                                                                                    VarContext<T> dfIn,
                                                                                    polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                    polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLocalDecl` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowFormal(polyglot.ast.Formal n,
                                                                                 VarContext<T> dfIn,
                                                                                 polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFormal` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowLit(polyglot.ast.Lit n,
                                                                              VarContext<T> dfIn,
                                                                              polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                              polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLit` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowEmpty

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowEmpty(polyglot.ast.Empty n,
                                                                                VarContext<T> dfIn,
                                                                                polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowEmpty` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowLocalAssign(polyglot.ast.LocalAssign n,
                                                                                      VarContext<T> dfIn,
                                                                                      polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                      polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLocalAssign` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowArrayAccessAssign

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayAccessAssign` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowFieldAssign(polyglot.ast.FieldAssign n,
                                                                                      VarContext<T> dfIn,
                                                                                      polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                      polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFieldAssign` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowFieldDecl(polyglot.ast.FieldDecl n,
                                                                                    VarContext<T> dfIn,
                                                                                    polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                    polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFieldDecl` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowArrayAccess(polyglot.ast.ArrayAccess n,
                                                                                      VarContext<T> dfIn,
                                                                                      polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                      polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayAccess` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowArrayInit

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayInit` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowStmt(polyglot.ast.Stmt n,
                                                                               VarContext<T> dfIn,
                                                                               polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                               polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Compute the dataflow for `n`
      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<T>> flowTry(polyglot.ast.Try n,
                                                                              VarContext<T> dfIn,
                                                                              polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                              polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowTry` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowCatch(polyglot.ast.Catch n,
                                                                                VarContext<T> dfIn,
                                                                                polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowCatch` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowFinally(polyglot.ast.Block n,
                                                                                  VarContext<T> dfIn,
                                                                                  polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                  polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFinally` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowEval

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowEval(polyglot.ast.Eval n,
                                                                               VarContext<T> dfIn,
                                                                               polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                               polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowEval` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowBranch

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowBranch(polyglot.ast.Branch n,
                                                                                 VarContext<T> dfIn,
                                                                                 polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowBranch` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowLabeled

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowLabeled(polyglot.ast.Labeled n,
                                                                                  VarContext<T> dfIn,
                                                                                  polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                  polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLabeled` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowExpr(polyglot.ast.Expr n,
                                                                               VarContext<T> dfIn,
                                                                               polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                               polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowExpr` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowIf(polyglot.ast.If n,
                                                                             VarContext<T> dfIn,
                                                                             polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                             polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowIf` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowBlock

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowBlock` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowWhile

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowWhile(polyglot.ast.While n,
                                                                                VarContext<T> dfIn,
                                                                                polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowWhile` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowDo

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowDo(polyglot.ast.Do n,
                                                                             VarContext<T> dfIn,
                                                                             polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                             polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowDo` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowLocal(polyglot.ast.Local n,
                                                                                VarContext<T> dfIn,
                                                                                polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLocal` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowSuppress

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowSuppress(Suppress n,
                                                                                   VarContext<T> dfIn,
                                                                                   polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                   polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowSuppress` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowSynchronized

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowSynchronized(polyglot.ast.Synchronized n,
                                                                                       VarContext<T> dfIn,
                                                                                       polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                       polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowSynchronized` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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<T>> flowSpecial(polyglot.ast.Special n,
                                                                                  VarContext<T> dfIn,
                                                                                  polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                  polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowSpecial` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowCodeDecl

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

      Compute the dataflow for `n`
      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

    - #### flowMethodDecl

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowMethodDecl(polyglot.ast.MethodDecl n,
                                                                                     VarContext<T> dfIn,
                                                                                     polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                     polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowMethodDecl` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowConstructorDecl

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowConstructorDecl(polyglot.ast.ConstructorDecl n,
                                                                                          VarContext<T> dfIn,
                                                                                          polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowConstructorDecl` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### flowInitializer

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> flowInitializer(polyglot.ast.Initializer n,
                                                                                      VarContext<T> dfIn,
                                                                                      polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                      polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowInitializer` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`
      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

    - #### ignoreNode

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<T>> ignoreNode(VarContext<T> dfIn,
                                                                                 polyglot.visit.FlowGraph<VarContext<T>> graph,
                                                                                 polyglot.visit.FlowGraph.Peer<VarContext<T>> peer)

      Description copied from interface: `DataFlowDispatch`
      Ignore the node (i.e., it is a no-op).
      Specified by:
        `ignoreNode` in interface `DataFlowDispatch<VarContext<T extends AbstractValue<T>>>`