accrue.analysis.notnulldataflow

## Class NotNullDataFlow

- 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<NotNullAbsVal>
            - - accrue.analysis.notnulldataflow.NotNullDataFlow

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

      public class NotNullDataFlow
      extends VarContextDataFlow<NotNullAbsVal>
      implements JL5DataFlowDispatch<VarContext<NotNullAbsVal>>

  Interprocedural dataflow analysis to determine which local variables and locations cannot be null. This information is stored in the appropriate extension objects, and is then used in subsequent analyses to improve the precision of analysis, since various NullPointerExceptions can be determined not to be thrown.

- - ### 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 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
    `NotNullDataFlow(NotNullAnalysisUtil autil, WorkQueue<VarContext<NotNullAbsVal>> wq, polyglot.frontend.Job job, polyglot.types.TypeSystem ts, polyglot.ast.NodeFactory nf)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `check(polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> p)` "Check" the nodes of the graph for the not null analysis.
    `protected void` | `check(polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.ast.Term n, boolean entry, VarContext<NotNullAbsVal> inItem, java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>> outItems)`
    `protected java.lang.Object` | `clone()`
    `protected VarContext<NotNullAbsVal>` | `constructMissingContextForEdgeKey(polyglot.visit.FlowGraph.EdgeKey ek, FinalVarContext<NotNullAbsVal> f, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` If an edge is missing this method is called to approximate the variable context
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowArrayAccess(polyglot.ast.ArrayAccess n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowAssign(polyglot.ast.Assign n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowBinary(polyglot.ast.Binary n, VarContext<NotNullAbsVal> dfIn, VarContext<NotNullAbsVal> trueItem, VarContext<NotNullAbsVal> falseItem, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowCall(polyglot.ast.Call n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowCast(polyglot.ast.Cast n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowCatch(polyglot.ast.Catch n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowCodeDecl(polyglot.ast.CodeDecl n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowConditional(polyglot.ast.Conditional n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowConstructorCall(polyglot.ast.ConstructorCall n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowEnumConstant(polyglot.ext.jl5.ast.EnumConstant n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowEnumConstantDecl(polyglot.ext.jl5.ast.EnumConstantDecl n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` The following methods provide support for JL5 language features.
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowExpr(polyglot.ast.Expr n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowExtendedFor(polyglot.ext.jl5.ast.ExtendedFor n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowField(polyglot.ast.Field n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowFieldDecl(polyglot.ast.FieldDecl n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowFinally(polyglot.ast.Block n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowFormal(polyglot.ast.Formal n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `protected java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowImpl(VarContext<NotNullAbsVal> trueItem, VarContext<NotNullAbsVal> falseItem, VarContext<NotNullAbsVal> otherItem, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowInstanceof(polyglot.ast.Instanceof n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowLit(polyglot.ast.Lit n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowLocalDecl(polyglot.ast.LocalDecl n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowNew(polyglot.ast.New n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowNewArray(polyglot.ast.NewArray n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowParamTypeNode(polyglot.ext.jl5.ast.ParamTypeNode n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowReturn(polyglot.ast.Return n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowStmt(polyglot.ast.Stmt n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowThrow(polyglot.ast.Throw n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowTry(polyglot.ast.Try n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowTypeNode(polyglot.ast.TypeNode n, VarContext<NotNullAbsVal> dfIn, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `flowUnary(polyglot.ast.Unary n, VarContext<NotNullAbsVal> dfIn, VarContext<NotNullAbsVal> trueItem, VarContext<NotNullAbsVal> falseItem, polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)` Compute the dataflow for `n`
    `protected static java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>>` | `itemToMapWithExceptionResults(VarContext<NotNullAbsVal> i, java.util.Set<polyglot.visit.FlowGraph.EdgeKey> edgeKeys, polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)`

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

      `argumentsOnResultStack, autil, checkInvariants, confluence, createInitialItem, dataflow, edgeKeyConvert, finalVarContextToDataFlowMap, flow, flow, flowArrayAccessAssign, flowArrayInit, flowAssert, flowBlock, flowBranch, flowConstructorDecl, flowDo, flowEmpty, flowEval, flowFieldAssign, flowIf, flowInitializer, flowLabeled, flowLocal, flowLocalAssign, flowMethodDecl, flowSpecial, 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

      `equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface accrue.analysis.interprocanalysis.DataFlowDispatch

      `flowArrayAccessAssign, flowArrayInit, flowAssert, flowBlock, flowBranch, flowConstructorDecl, flowDo, flowEmpty, flowEval, flowFieldAssign, flowIf, flowInitializer, flowLabeled, flowLocal, flowLocalAssign, flowMethodDecl, flowSpecial, flowSuppress, flowSynchronized, flowWhile, ignoreNode`

- - ### Constructor Detail

    - #### NotNullDataFlow

          public NotNullDataFlow(NotNullAnalysisUtil autil,
                         WorkQueue<VarContext<NotNullAbsVal>> wq,
                         polyglot.frontend.Job job,
                         polyglot.types.TypeSystem ts,
                         polyglot.ast.NodeFactory nf)

  - ### Method Detail

    - #### flowImpl

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

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

    - #### flowTypeNode

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

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

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

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

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

    - #### flowFinally

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

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

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

    - #### flowCodeDecl

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

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

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

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

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

    - #### flowConditional

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

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

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

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

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

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowArrayAccess` in interface `DataFlowDispatch<VarContext<NotNullAbsVal>>`
      Overrides:
        `flowArrayAccess` in class `VarContextDataFlow<NotNullAbsVal>`
      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

    - #### flowConstructorCall

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

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

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

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

    - #### flowAssign

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

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

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

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

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

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

      Description copied from interface: `DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowFormal` in interface `DataFlowDispatch<VarContext<NotNullAbsVal>>`
      Overrides:
        `flowFormal` in class `VarContextDataFlow<NotNullAbsVal>`
      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

    - #### clone

          protected java.lang.Object clone()
                                    throws java.lang.CloneNotSupportedException

      Overrides:
        `clone` in class `java.lang.Object`
      Throws:
        `java.lang.CloneNotSupportedException`

    - #### check

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

      "Check" the nodes of the graph for the not null analysis. This actually consists of setting various "not null" flags in the extensions.
      Overrides:
        `check` in class `polyglot.visit.DataFlow<VarContext<NotNullAbsVal>>`
      Throws:
        `polyglot.types.SemanticException`

    - #### check

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

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

    - #### itemToMapWithExceptionResults

          protected static java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>> itemToMapWithExceptionResults(VarContext<NotNullAbsVal> i,
                                                                                                                java.util.Set<polyglot.visit.FlowGraph.EdgeKey> edgeKeys,
                                                                                                                polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)

    - #### constructMissingContextForEdgeKey

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

      Description copied from class: `VarContextDataFlow`
      If an edge is missing this method is called to approximate the variable context
      Overrides:
        `constructMissingContextForEdgeKey` in class `VarContextDataFlow<NotNullAbsVal>`
      Parameters:
        `ek` - edge key of missing edge
        `f` - the finalVarContext that we were using.
      Returns:
        variable context

    - #### flowEnumConstantDecl

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>> flowEnumConstantDecl(polyglot.ext.jl5.ast.EnumConstantDecl n,
                                                                                                       VarContext<NotNullAbsVal> dfIn,
                                                                                                       polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph,
                                                                                                       polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)

      The following methods provide support for JL5 language features. We include them here rather than in a subclass, since many (most?) uses of Accrue will be for JL5 or above
      Specified by:
        `flowEnumConstantDecl` in interface `JL5DataFlowDispatch<VarContext<NotNullAbsVal>>`
      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

    - #### flowEnumConstant

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>> flowEnumConstant(polyglot.ext.jl5.ast.EnumConstant n,
                                                                                                   VarContext<NotNullAbsVal> dfIn,
                                                                                                   polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph,
                                                                                                   polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)

      Description copied from interface: `JL5DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowEnumConstant` in interface `JL5DataFlowDispatch<VarContext<NotNullAbsVal>>`
      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

    - #### flowExtendedFor

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>> flowExtendedFor(polyglot.ext.jl5.ast.ExtendedFor n,
                                                                                                  VarContext<NotNullAbsVal> dfIn,
                                                                                                  polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph,
                                                                                                  polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)

      Description copied from interface: `JL5DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowExtendedFor` in interface `JL5DataFlowDispatch<VarContext<NotNullAbsVal>>`
      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

    - #### flowParamTypeNode

          public java.util.Map<polyglot.visit.FlowGraph.EdgeKey,VarContext<NotNullAbsVal>> flowParamTypeNode(polyglot.ext.jl5.ast.ParamTypeNode n,
                                                                                                    VarContext<NotNullAbsVal> dfIn,
                                                                                                    polyglot.visit.FlowGraph<VarContext<NotNullAbsVal>> graph,
                                                                                                    polyglot.visit.FlowGraph.Peer<VarContext<NotNullAbsVal>> peer)

      Description copied from interface: `JL5DataFlowDispatch`
      Compute the dataflow for `n`
      Specified by:
        `flowParamTypeNode` in interface `JL5DataFlowDispatch<VarContext<NotNullAbsVal>>`
      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