accrue.analysis.interprocanalysis

## Interface DataFlowDispatch<DFItem extends polyglot.visit.DataFlow.Item>

- Type Parameters:
    `DFItem` - dataflow item type
  All Known Subinterfaces:
    JL5DataFlowDispatch<DFItem>
  All Known Implementing Classes:
    AbstractDataFlowDispatch, AntiDepDataFlow, DefUseDataFlow, NotNullDataFlow, VarContextDataFlow

      public interface DataFlowDispatch<DFItem extends polyglot.visit.DataFlow.Item>

  Helper interface to assist in dispatch for dataflow implementations.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowArrayAccess(polyglot.ast.ArrayAccess n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowArrayAccessAssign(polyglot.ast.ArrayAccessAssign n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowArrayInit(polyglot.ast.ArrayInit n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowAssert(polyglot.ast.Assert n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowBinary(polyglot.ast.Binary n, DFItem dfIn, DFItem trueItem, DFItem falseItem, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowBlock(polyglot.ast.Block n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowBranch(polyglot.ast.Branch n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowCall(polyglot.ast.Call n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowCast(polyglot.ast.Cast n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowCatch(polyglot.ast.Catch n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowConditional(polyglot.ast.Conditional n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowConstructorCall(polyglot.ast.ConstructorCall n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowConstructorDecl(polyglot.ast.ConstructorDecl n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowDo(polyglot.ast.Do n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowEmpty(polyglot.ast.Empty n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowEval(polyglot.ast.Eval n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowExpr(polyglot.ast.Expr n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowField(polyglot.ast.Field n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowFieldAssign(polyglot.ast.FieldAssign n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowFieldDecl(polyglot.ast.FieldDecl n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowFinally(polyglot.ast.Block n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowFormal(polyglot.ast.Formal n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowIf(polyglot.ast.If n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowInitializer(polyglot.ast.Initializer n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowInstanceof(polyglot.ast.Instanceof n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowLabeled(polyglot.ast.Labeled n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowLit(polyglot.ast.Lit n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowLocal(polyglot.ast.Local n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowLocalAssign(polyglot.ast.LocalAssign n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowLocalDecl(polyglot.ast.LocalDecl n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowMethodDecl(polyglot.ast.MethodDecl n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowNew(polyglot.ast.New n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowNewArray(polyglot.ast.NewArray n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowReturn(polyglot.ast.Return n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowSpecial(polyglot.ast.Special n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowSuppress(Suppress n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowSynchronized(polyglot.ast.Synchronized n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowThrow(polyglot.ast.Throw n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowTry(polyglot.ast.Try n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowTypeNode(polyglot.ast.TypeNode n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowUnary(polyglot.ast.Unary n, DFItem dfIn, DFItem trueItem, DFItem falseItem, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `flowWhile(polyglot.ast.While n, DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem>` | `ignoreNode(DFItem dfIn, polyglot.visit.FlowGraph<DFItem> graph, polyglot.visit.FlowGraph.Peer<DFItem> peer)` Ignore the node (i.e., it is a no-op).

- - ### Method Detail

    - #### flowArrayAccess

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

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

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowArrayAccessAssign(polyglot.ast.ArrayAccessAssign n,
                                                                                     DFItem dfIn,
                                                                                     polyglot.visit.FlowGraph<DFItem> graph,
                                                                                     polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowArrayInit

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowArrayInit(polyglot.ast.ArrayInit n,
                                                                             DFItem dfIn,
                                                                             polyglot.visit.FlowGraph<DFItem> graph,
                                                                             polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowAssert

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowAssert(polyglot.ast.Assert n,
                                                                          DFItem dfIn,
                                                                          polyglot.visit.FlowGraph<DFItem> graph,
                                                                          polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowBinary

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowBinary(polyglot.ast.Binary n,
                                                                          DFItem dfIn,
                                                                          DFItem trueItem,
                                                                          DFItem falseItem,
                                                                          polyglot.visit.FlowGraph<DFItem> graph,
                                                                          polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowBlock

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowBlock(polyglot.ast.Block n,
                                                                         DFItem dfIn,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowBranch

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowBranch(polyglot.ast.Branch n,
                                                                          DFItem dfIn,
                                                                          polyglot.visit.FlowGraph<DFItem> graph,
                                                                          polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowCall

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowCall(polyglot.ast.Call n,
                                                                        DFItem dfIn,
                                                                        polyglot.visit.FlowGraph<DFItem> graph,
                                                                        polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowCast

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowCast(polyglot.ast.Cast n,
                                                                        DFItem dfIn,
                                                                        polyglot.visit.FlowGraph<DFItem> graph,
                                                                        polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowCatch

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowCatch(polyglot.ast.Catch n,
                                                                         DFItem dfIn,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowConditional

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowConditional(polyglot.ast.Conditional n,
                                                                               DFItem dfIn,
                                                                               polyglot.visit.FlowGraph<DFItem> graph,
                                                                               polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowConstructorCall

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowConstructorCall(polyglot.ast.ConstructorCall n,
                                                                                   DFItem dfIn,
                                                                                   polyglot.visit.FlowGraph<DFItem> graph,
                                                                                   polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowConstructorDecl

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowConstructorDecl(polyglot.ast.ConstructorDecl n,
                                                                                   DFItem dfIn,
                                                                                   polyglot.visit.FlowGraph<DFItem> graph,
                                                                                   polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowDo

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowDo(polyglot.ast.Do n,
                                                                      DFItem dfIn,
                                                                      polyglot.visit.FlowGraph<DFItem> graph,
                                                                      polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowEmpty

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowEmpty(polyglot.ast.Empty n,
                                                                         DFItem dfIn,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowEval

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowEval(polyglot.ast.Eval n,
                                                                        DFItem dfIn,
                                                                        polyglot.visit.FlowGraph<DFItem> graph,
                                                                        polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowExpr

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowExpr(polyglot.ast.Expr n,
                                                                        DFItem dfIn,
                                                                        polyglot.visit.FlowGraph<DFItem> graph,
                                                                        polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowField

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowField(polyglot.ast.Field n,
                                                                         DFItem dfIn,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowFieldDecl

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowFieldDecl(polyglot.ast.FieldDecl n,
                                                                             DFItem dfIn,
                                                                             polyglot.visit.FlowGraph<DFItem> graph,
                                                                             polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowFieldAssign

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowFieldAssign(polyglot.ast.FieldAssign n,
                                                                               DFItem dfIn,
                                                                               polyglot.visit.FlowGraph<DFItem> graph,
                                                                               polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowFormal

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowFormal(polyglot.ast.Formal n,
                                                                          DFItem dfIn,
                                                                          polyglot.visit.FlowGraph<DFItem> graph,
                                                                          polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowIf

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowIf(polyglot.ast.If n,
                                                                      DFItem dfIn,
                                                                      polyglot.visit.FlowGraph<DFItem> graph,
                                                                      polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowInitializer

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowInitializer(polyglot.ast.Initializer n,
                                                                               DFItem dfIn,
                                                                               polyglot.visit.FlowGraph<DFItem> graph,
                                                                               polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowInstanceof

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowInstanceof(polyglot.ast.Instanceof n,
                                                                              DFItem dfIn,
                                                                              polyglot.visit.FlowGraph<DFItem> graph,
                                                                              polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowLabeled

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowLabeled(polyglot.ast.Labeled n,
                                                                           DFItem dfIn,
                                                                           polyglot.visit.FlowGraph<DFItem> graph,
                                                                           polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowLit

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowLit(polyglot.ast.Lit n,
                                                                       DFItem dfIn,
                                                                       polyglot.visit.FlowGraph<DFItem> graph,
                                                                       polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowLocal

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowLocal(polyglot.ast.Local n,
                                                                         DFItem dfIn,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowLocalAssign

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowLocalAssign(polyglot.ast.LocalAssign n,
                                                                               DFItem dfIn,
                                                                               polyglot.visit.FlowGraph<DFItem> graph,
                                                                               polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowLocalDecl

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowLocalDecl(polyglot.ast.LocalDecl n,
                                                                             DFItem dfIn,
                                                                             polyglot.visit.FlowGraph<DFItem> graph,
                                                                             polyglot.visit.FlowGraph.Peer<DFItem> 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

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowMethodDecl(polyglot.ast.MethodDecl n,
                                                                              DFItem dfIn,
                                                                              polyglot.visit.FlowGraph<DFItem> graph,
                                                                              polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowNew

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowNew(polyglot.ast.New n,
                                                                       DFItem dfIn,
                                                                       polyglot.visit.FlowGraph<DFItem> graph,
                                                                       polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowNewArray

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowNewArray(polyglot.ast.NewArray n,
                                                                            DFItem dfIn,
                                                                            polyglot.visit.FlowGraph<DFItem> graph,
                                                                            polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowReturn

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowReturn(polyglot.ast.Return n,
                                                                          DFItem dfIn,
                                                                          polyglot.visit.FlowGraph<DFItem> graph,
                                                                          polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowSpecial

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowSpecial(polyglot.ast.Special n,
                                                                           DFItem dfIn,
                                                                           polyglot.visit.FlowGraph<DFItem> graph,
                                                                           polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowSuppress

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowSuppress(Suppress n,
                                                                            DFItem dfIn,
                                                                            polyglot.visit.FlowGraph<DFItem> graph,
                                                                            polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowSynchronized

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowSynchronized(polyglot.ast.Synchronized n,
                                                                                DFItem dfIn,
                                                                                polyglot.visit.FlowGraph<DFItem> graph,
                                                                                polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowThrow

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowThrow(polyglot.ast.Throw n,
                                                                         DFItem dfIn,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowTry(polyglot.ast.Try n,
                                                                       DFItem dfIn,
                                                                       polyglot.visit.FlowGraph<DFItem> graph,
                                                                       polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowFinally

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowFinally(polyglot.ast.Block n,
                                                                           DFItem dfIn,
                                                                           polyglot.visit.FlowGraph<DFItem> graph,
                                                                           polyglot.visit.FlowGraph.Peer<DFItem> 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

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowTypeNode(polyglot.ast.TypeNode n,
                                                                            DFItem dfIn,
                                                                            polyglot.visit.FlowGraph<DFItem> graph,
                                                                            polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowUnary

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowUnary(polyglot.ast.Unary n,
                                                                         DFItem dfIn,
                                                                         DFItem trueItem,
                                                                         DFItem falseItem,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### flowWhile

          java.util.Map<polyglot.visit.FlowGraph.EdgeKey,DFItem> flowWhile(polyglot.ast.While n,
                                                                         DFItem dfIn,
                                                                         polyglot.visit.FlowGraph<DFItem> graph,
                                                                         polyglot.visit.FlowGraph.Peer<DFItem> 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

    - #### ignoreNode

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

      Ignore the node (i.e., it is a no-op).