accrue.analysis.antidep

## Class AntiDepDataFlow

- 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<AntiDepAbsVal>
            - - accrue.analysis.antidep.AntiDepDataFlow

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

      public class AntiDepDataFlow
      extends VarContextDataFlow<AntiDepAbsVal>

  This analysis works as follows: At every use, an edge is created for the reference and associated with the locations referenced. The edge is only propagated along forward edges. Each use that "flows" to an assignment that may define a referenced location has (may have) an anti-dependency on that assignment

- - ### 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 AntiDepAnalysisUtil` | `autil`
    `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
    `AntiDepDataFlow(AntiDepAnalysisUtil autil, WorkQueue<VarContext<AntiDepAbsVal>> 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<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> p)`
    `protected void` | `check(polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.ast.Term n, boolean entry, VarContext<AntiDepAbsVal> inItem, java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>> outItems)`
    `protected AntiDepAbsVal` | `createHeapUse(java.util.Set<AbstractLocation> locs, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `protected AntiDepAbsVal` | `createLocalUse(java.lang.String defined, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `protected FinalVarContext<AntiDepAbsVal>` | `flowArithmeticException(VarContext<AntiDepAbsVal> dfIn, polyglot.ast.Binary cause, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowArrayAccess(polyglot.ast.ArrayAccess n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowArrayAccessAssign(polyglot.ast.ArrayAccessAssign n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowArrayInit(polyglot.ast.ArrayInit n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowBinary(polyglot.ast.Binary n, VarContext<AntiDepAbsVal> dfIn, VarContext<AntiDepAbsVal> trueItem, VarContext<AntiDepAbsVal> falseItem, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowCall(polyglot.ast.Call n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowCast(polyglot.ast.Cast n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowCatch(polyglot.ast.Catch n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `protected FinalVarContext<AntiDepAbsVal>` | `flowClassCastException(VarContext<AntiDepAbsVal> dfIn, polyglot.ast.Cast cause, AntiDepAbsVal causeDFI, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowCodeDecl(polyglot.ast.CodeDecl n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowConstructorCall(polyglot.ast.ConstructorCall n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowExpr(polyglot.ast.Expr n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowField(polyglot.ast.Field n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowFieldAssign(polyglot.ast.FieldAssign n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowFieldDecl(polyglot.ast.FieldDecl n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowFormal(polyglot.ast.Formal n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowIf(polyglot.ast.If n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `protected java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowImpl(VarContext<AntiDepAbsVal> trueItem, VarContext<AntiDepAbsVal> falseItem, VarContext<AntiDepAbsVal> otherItem, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `protected FinalVarContext<AntiDepAbsVal>` | `flowImpossibleException(FinalVarContext<AntiDepAbsVal> res, polyglot.types.ClassType exType, polyglot.ast.Node cause)`
    `protected FinalVarContext<AntiDepAbsVal>` | `flowImpossibleException(VarContext<AntiDepAbsVal> dfIn, polyglot.types.ClassType exType, polyglot.ast.Node cause, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowInstanceof(polyglot.ast.Instanceof n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowLit(polyglot.ast.Lit n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowLocal(polyglot.ast.Local n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowLocalAssign(polyglot.ast.LocalAssign n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowLocalDecl(polyglot.ast.LocalDecl n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowNew(polyglot.ast.New n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowNewArray(polyglot.ast.NewArray n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `protected FinalVarContext<AntiDepAbsVal>` | `flowNullPointerException(VarContext<AntiDepAbsVal> dfIn, polyglot.ast.Node cause, AntiDepAbsVal causeDFI, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `protected FinalVarContext<AntiDepAbsVal>` | `flowOutOfBoundsException(VarContext<AntiDepAbsVal> dfIn, polyglot.ast.Expr cause, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowReturn(polyglot.ast.Return n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowSpecial(polyglot.ast.Special n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowStmt(polyglot.ast.Stmt n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowThrow(polyglot.ast.Throw n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowTry(polyglot.ast.Try n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowTypeNode(polyglot.ast.TypeNode n, VarContext<AntiDepAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `flowUnary(polyglot.ast.Unary n, VarContext<AntiDepAbsVal> dfIn, VarContext<AntiDepAbsVal> trueItem, VarContext<AntiDepAbsVal> falseItem, polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)` Compute the dataflow for `n`
    `protected FinalVarContext<AntiDepAbsVal>` | `flowUncheckedException(VarContext<AntiDepAbsVal> dfIn, polyglot.types.ClassType exType, polyglot.ast.Node cause, polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)`
    `protected static java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<AntiDepAbsVal>>` | `itemToMapWithExceptionResults(VarContext<AntiDepAbsVal> dfIn, java.util.Set<polyglot.visit.FlowGraph.EdgeKey> edgeKeys)`
    `protected int` | `postorderNodeIDs(polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> p, int count, java.util.Set<NodeIdentifier> visited)`
    `protected AntiDepAbsVal` | `upperBound(java.util.Collection<AntiDepAbsVal> 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, flowFinally, 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 AntiDepAnalysisUtil autil

    - #### nodePostordering

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

  - ### Constructor Detail

    - #### AntiDepDataFlow

          public AntiDepDataFlow(AntiDepAnalysisUtil autil,
                         WorkQueue<VarContext<AntiDepAbsVal>> 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<AntiDepAbsVal>> p,
                             int count,
                             java.util.Set<NodeIdentifier> visited)

    - #### check

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

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

    - #### check

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

      Specified by:
        `check` in class `polyglot.visit.DataFlow<VarContext<AntiDepAbsVal>>`

    - #### flowImpl

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

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

    - #### flowCodeDecl

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

      Description copied from class: `VarContextDataFlow`
      Compute the dataflow for `n`
      Overrides:
        `flowCodeDecl` in class `VarContextDataFlow<AntiDepAbsVal>`
      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<AntiDepAbsVal>> flowLocalDecl(polyglot.ast.LocalDecl n,
                                                                                                VarContext<AntiDepAbsVal> dfIn,
                                                                                                polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph,
                                                                                                polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)

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

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

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowLocalAssign` in interface `DataFlowDispatch<VarContext<AntiDepAbsVal>>`
      Overrides:
        `flowLocalAssign` in class `VarContextDataFlow<AntiDepAbsVal>`
      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<AntiDepAbsVal>> flowField(polyglot.ast.Field n,
                                                                                            VarContext<AntiDepAbsVal> dfIn,
                                                                                            polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph,
                                                                                            polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)

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

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

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayAccess` in interface `DataFlowDispatch<VarContext<AntiDepAbsVal>>`
      Overrides:
        `flowArrayAccess` in class `VarContextDataFlow<AntiDepAbsVal>`
      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<AntiDepAbsVal>> flowArrayAccessAssign(polyglot.ast.ArrayAccessAssign n,
                                                                                                        VarContext<AntiDepAbsVal> dfIn,
                                                                                                        polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph,
                                                                                                        polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayAccessAssign` in interface `DataFlowDispatch<VarContext<AntiDepAbsVal>>`
      Overrides:
        `flowArrayAccessAssign` in class `VarContextDataFlow<AntiDepAbsVal>`
      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<AntiDepAbsVal>> flowArrayInit(polyglot.ast.ArrayInit n,
                                                                                                VarContext<AntiDepAbsVal> dfIn,
                                                                                                polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph,
                                                                                                polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      Description copied from class: `VarContextDataFlow`
      Compute the dataflow for `n`
      Overrides:
        `flowStmt` in class `VarContextDataFlow<AntiDepAbsVal>`
      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<AntiDepAbsVal>> flowTypeNode(polyglot.ast.TypeNode n,
                                                                                               VarContext<AntiDepAbsVal> dfIn,
                                                                                               polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph,
                                                                                               polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowTypeNode` in interface `DataFlowDispatch<VarContext<AntiDepAbsVal>>`
      Overrides:
        `flowTypeNode` in class `VarContextDataFlow<AntiDepAbsVal>`
      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<AntiDepAbsVal>> flowTry(polyglot.ast.Try n,
                                                                                          VarContext<AntiDepAbsVal> dfIn,
                                                                                          polyglot.visit.FlowGraph<VarContext<AntiDepAbsVal>> graph,
                                                                                          polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)

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

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowIf` in interface `DataFlowDispatch<VarContext<AntiDepAbsVal>>`
      Overrides:
        `flowIf` in class `VarContextDataFlow<AntiDepAbsVal>`
      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<AntiDepAbsVal> flowUncheckedException(VarContext<AntiDepAbsVal> dfIn,
                                                              polyglot.types.ClassType exType,
                                                              polyglot.ast.Node cause,
                                                              polyglot.visit.FlowGraph.Peer<VarContext<AntiDepAbsVal>> peer)

    - #### flowImpossibleException

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

    - #### flowImpossibleException

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

    - #### flowNullPointerException

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

    - #### flowArithmeticException

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

    - #### flowOutOfBoundsException

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

    - #### flowClassCastException

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

    - #### upperBound

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

    - #### createLocalUse

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

    - #### createHeapUse

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

    - #### itemToMapWithExceptionResults

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