Analysis (checker-framework 3.1.0 API)

java.lang.Object
- org.checkerframework.dataflow.analysis.Analysis<A,S,T>

Type Parameters:

A - the abstract value type to be tracked by the analysis

S - the store type used in the analysis

T - the transfer function type that is used to approximated runtime behavior

Direct Known Subclasses:

CFAbstractAnalysis
```
public class Analysis<A extends AbstractValue<A>,S extends Store<S>,T extends TransferFunction<A,S>>
extends Object
```
An implementation of an iterative algorithm to solve a org.checkerframework.dataflow problem, given a control flow graph and a transfer function.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`Analysis.Worklist` A worklist is a priority queue of blocks in which the order is given by depth-first ordering to place non-loop predecessors ahead of successors.

Field Summary

Fields
Modifier and Type	Field and Description
`protected @Nullable IdentityHashMap<Block,Integer>`	`blockCount` Number of times every block has been analyzed since the last time widening was applied.
`protected @Nullable ControlFlowGraph`	`cfg` The current control flow graph to perform the analysis on.
`protected @Nullable TransferInput<A,S>`	`currentInput` The current transfer input when the analysis is running.
`protected @Nullable Node`	`currentNode` The node that is currently handled in the analysis (if it is running).
`protected @Nullable Tree`	`currentTree` The tree that is currently being looked at.
`protected IdentityHashMap<Block,S>`	`elseStores` Else stores before every basic block (assumed to be 'no information' if not present).
`protected ProcessingEnvironment`	`env` The associated processing environment.
`HashMap<Element,A>`	`finalLocalValues` Map from (effectively final) local variable elements to their abstract value.
`protected IdentityHashMap<Block,TransferInput<A,S>>`	`inputs` The transfer inputs before every basic block (assumed to be 'no information' if not present).
`protected boolean`	`isRunning` Is the analysis currently running?
`protected int`	`maxCountBeforeWidening` Number of times a block can be analyzed before widening.
`protected IdentityHashMap<Node,A>`	`nodeValues` Abstract values of nodes.
`protected IdentityHashMap<ReturnNode,TransferResult<A,S>>`	`storesAtReturnStatements` The stores after every return statement.
`protected IdentityHashMap<Block,S>`	`thenStores` Then stores before every basic block (assumed to be 'no information' if not present).
`protected T`	`transferFunction` The transfer function for regular nodes.
`protected Types`	`types` Instance of the types utility.
`protected Analysis.Worklist`	`worklist` The worklist used for the fix-point iteration.

Constructor Summary

Constructors
Constructor and Description
`Analysis(ProcessingEnvironment env)` Construct an object that can perform a org.checkerframework.dataflow analysis over a control flow graph.
`Analysis(T transfer, int maxCountBeforeWidening, ProcessingEnvironment env)` Construct an object that can perform a org.checkerframework.dataflow analysis over a control flow graph, given a transfer function.
`Analysis(T transfer, ProcessingEnvironment env)` Construct an object that can perform a org.checkerframework.dataflow analysis over a control flow graph, given a transfer function.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addStoreBefore(Block b, @Nullable Node node, S s, Store.Kind kind, boolean addBlockToWorklist)` Add a store before the basic block `b` by merging with the existing stores for that location.
`protected void`	`addToWorklist(Block b)` Add a basic block to the worklist.
`protected TransferResult<A,S>`	`callTransferFunction(Node node, TransferInput<A,S> store)` Call the transfer function for node `node`, and set that node as current node first.
`@Nullable ClassTree`	`getContainingClass(Tree t)` Get the `ClassTree` of the current CFG if the argument `Tree` maps to a `Node` in the CFG or null otherwise.
`@Nullable MethodTree`	`getContainingMethod(Tree t)` Get the `MethodTree` of the current CFG if the argument `Tree` maps to a `Node` in the CFG or null otherwise.
`@Nullable Tree`	`getCurrentTree()` The tree that is currently being looked at.
`ProcessingEnvironment`	`getEnv()`
`S`	`getExceptionalExitStore()`
`@Nullable TransferInput<A,S>`	`getInput(Block b)` Read the `TransferInput` for a particular basic block (or `null` if none exists yet).
`protected @Nullable TransferInput<A,S>`	`getInputBefore(Block b)`
`@Nullable Set<Node>`	`getNodesForTree(Tree t)` Get the set of `Node`s for a given `Tree`.
`IdentityHashMap<Node,A>`	`getNodeValues()` Return all current node values.
`S`	`getRegularExitStore()`
`AnalysisResult<A,S>`	`getResult()` The result of running the analysis.
`List<Pair<ReturnNode,TransferResult<A,S>>>`	`getReturnStatementStores()` The transfer results for each return node in the CFG.
`protected S`	`getStoreBefore(Block b, Store.Kind kind)`
`T`	`getTransferFunction()` The current transfer function.
`Types`	`getTypes()`
`A`	`getValue(Node n)`
`A`	`getValue(Tree t)`
`protected void`	`init(ControlFlowGraph cfg)` Initialize the analysis with a new control flow graph.
`boolean`	`isRunning()` Is the analysis currently running?
`void`	`performAnalysis(ControlFlowGraph cfg)` Perform the actual analysis.
`protected void`	`performAnalysisBlock(Block b)` Perform the actual analysis on one block.
`protected void`	`propagateStoresTo(Block succ, @Nullable Node node, TransferInput<A,S> currentInput, Store.FlowRule flowRule, boolean addToWorklistAgain)` Propagate the stores in currentInput to the successor block, succ, according to the flowRule.
`protected static <S> S`	`readFromStore(Map<Block,S> stores, Block b)` Read the `Store` for a particular basic block from a map of stores (or `null` if none exists yet).
`void`	`setCurrentTree(Tree currentTree)`
`protected boolean`	`updateNodeValues(Node node, TransferResult<A,S> transferResult)` Updates the value of node `node` to the value of the `transferResult`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - isRunning
```
protected boolean isRunning
```
    Is the analysis currently running?
  - transferFunction
```
protected T extends TransferFunction<A,S> transferFunction
```
    The transfer function for regular nodes.
  - cfg
```
protected @Nullable ControlFlowGraph cfg
```
    The current control flow graph to perform the analysis on.
  - env
```
protected final ProcessingEnvironment env
```
    The associated processing environment.
  - types
```
protected final Types types
```
    Instance of the types utility.
  - thenStores
```
protected final IdentityHashMap<Block,S extends Store<S>> thenStores
```
    Then stores before every basic block (assumed to be 'no information' if not present).
  - elseStores
```
protected final IdentityHashMap<Block,S extends Store<S>> elseStores
```
    Else stores before every basic block (assumed to be 'no information' if not present).
  - blockCount
```
protected final @Nullable IdentityHashMap<Block,Integer> blockCount
```
    Number of times every block has been analyzed since the last time widening was applied. Null, if maxCountBeforeWidening is -1 which implies widening isn't used for this analysis.
  - maxCountBeforeWidening
```
protected final int maxCountBeforeWidening
```
    Number of times a block can be analyzed before widening. -1 implies that widening shouldn't be used.
  - inputs
```
protected final IdentityHashMap<Block,TransferInput<A extends AbstractValue<A>,S extends Store<S>>> inputs
```
    The transfer inputs before every basic block (assumed to be 'no information' if not present).
  - storesAtReturnStatements
```
protected final IdentityHashMap<ReturnNode,TransferResult<A extends AbstractValue<A>,S extends Store<S>>> storesAtReturnStatements
```
    The stores after every return statement.
  - worklist
```
protected final Analysis.Worklist worklist
```
    The worklist used for the fix-point iteration.
  - nodeValues
```
protected final IdentityHashMap<Node,A extends AbstractValue<A>> nodeValues
```
    Abstract values of nodes.
  - finalLocalValues
```
public final HashMap<Element,A extends AbstractValue<A>> finalLocalValues
```
    Map from (effectively final) local variable elements to their abstract value.
  - currentNode
```
protected @Nullable Node currentNode
```
    The node that is currently handled in the analysis (if it is running). The following invariant holds:
```
   !isRunning ⇒ (currentNode == null)
 
```
  - currentTree
```
protected @Nullable Tree currentTree
```
    The tree that is currently being looked at. The transfer function can set this tree to make sure that calls to getValue will not return information for this given tree.
  - currentInput
```
protected @Nullable TransferInput<A extends AbstractValue<A>,S extends Store<S>> currentInput
```
    The current transfer input when the analysis is running.
- Constructor Detail
  - Analysis
```
public Analysis(ProcessingEnvironment env)
```
    Construct an object that can perform a org.checkerframework.dataflow analysis over a control flow graph. The transfer function is set later using setTransferFunction.
  - Analysis
```
public Analysis(T transfer,
                ProcessingEnvironment env)
```
    Construct an object that can perform a org.checkerframework.dataflow analysis over a control flow graph, given a transfer function.
  - Analysis
```
public Analysis(T transfer,
                int maxCountBeforeWidening,
                ProcessingEnvironment env)
```
    Construct an object that can perform a org.checkerframework.dataflow analysis over a control flow graph, given a transfer function.
- Method Detail
  - getCurrentTree
```
public @Nullable Tree getCurrentTree()
```
    The tree that is currently being looked at.
  - setCurrentTree
```
public void setCurrentTree(Tree currentTree)
```
  - getTransferFunction
```
public T getTransferFunction()
```
    The current transfer function.
  - getTypes
```
public Types getTypes()
```
  - getEnv
```
public ProcessingEnvironment getEnv()
```
  - performAnalysis
```
public void performAnalysis(ControlFlowGraph cfg)
```
    Perform the actual analysis.
  - performAnalysisBlock
```
protected void performAnalysisBlock(Block b)
```
    Perform the actual analysis on one block.
  - propagateStoresTo
```
protected void propagateStoresTo(Block succ,
                                 @Nullable Node node,
                                 TransferInput<A,S> currentInput,
                                 Store.FlowRule flowRule,
                                 boolean addToWorklistAgain)
```
    Propagate the stores in currentInput to the successor block, succ, according to the flowRule.
  - updateNodeValues
```
protected boolean updateNodeValues(Node node,
                                   TransferResult<A,S> transferResult)
```
    Updates the value of node node to the value of the transferResult. Returns true if the node's value changed, or a store was updated.
  - callTransferFunction
```
protected TransferResult<A,S> callTransferFunction(Node node,
                                                   TransferInput<A,S> store)
```
    Call the transfer function for node node, and set that node as current node first.
  - init
```
protected void init(ControlFlowGraph cfg)
```
    Initialize the analysis with a new control flow graph.
  - addToWorklist
```
protected void addToWorklist(Block b)
```
    Add a basic block to the worklist. If b is already present, the method does nothing.
  - addStoreBefore
```
protected void addStoreBefore(Block b,
                              @Nullable Node node,
                              S s,
                              Store.Kind kind,
                              boolean addBlockToWorklist)
```
    Add a store before the basic block b by merging with the existing stores for that location.
  - getInput
```
public @Nullable TransferInput<A,S> getInput(Block b)
```
    Read the TransferInput for a particular basic block (or null if none exists yet).
  - getInputBefore
```
protected @Nullable TransferInput<A,S> getInputBefore(Block b)
```
    Returns:
    
    the transfer input corresponding to the location right before the basic block b.
  - getStoreBefore
```
protected S getStoreBefore(Block b,
                           Store.Kind kind)
```
    Returns:
    
    the store corresponding to the location right before the basic block b.
  - readFromStore
```
protected static <S> S readFromStore(Map<Block,S> stores,
                                     Block b)
```
    Read the Store for a particular basic block from a map of stores (or null if none exists yet).
  - isRunning
```
public boolean isRunning()
```
    Is the analysis currently running?
  - getValue
```
public A getValue(Node n)
```
    Returns:
    
    the abstract value for Node n, or null if no information is available. Note that if the analysis has not finished yet, this value might not represent the final value for this node.
  - getNodeValues
```
public IdentityHashMap<Node,A> getNodeValues()
```
    Return all current node values.
  - getValue
```
public A getValue(Tree t)
```
    Returns:
    
    the abstract value for Tree t, or null if no information is available. Note that if the analysis has not finished yet, this value might not represent the final value for this node.
  - getNodesForTree
```
public @Nullable Set<Node> getNodesForTree(Tree t)
```
    Get the set of Nodes for a given Tree. Returns null for trees that don't produce a value.
  - getContainingMethod
```
public @Nullable MethodTree getContainingMethod(Tree t)
```
    Get the MethodTree of the current CFG if the argument Tree maps to a Node in the CFG or null otherwise.
  - getContainingClass
```
public @Nullable ClassTree getContainingClass(Tree t)
```
    Get the ClassTree of the current CFG if the argument Tree maps to a Node in the CFG or null otherwise.
  - getReturnStatementStores
```
public List<Pair<ReturnNode,TransferResult<A,S>>> getReturnStatementStores()
```
    The transfer results for each return node in the CFG.
  - getResult
```
public AnalysisResult<A,S> getResult()
```
    The result of running the analysis. This is only available once the analysis finished running.
  - getRegularExitStore
```
public S getRegularExitStore()
```
    Returns:
    
    the regular exit store, or null, if there is no such store (because the method cannot exit through the regular exit block).
  - getExceptionalExitStore
```
public S getExceptionalExitStore()
```
    Returns:
    
    the exceptional exit store.

Class Analysis<A extends AbstractValue<A>,S extends Store<S>,T extends TransferFunction<A,S>>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

isRunning

transferFunction

cfg

env

types

thenStores

elseStores

blockCount

maxCountBeforeWidening

inputs

storesAtReturnStatements

worklist

nodeValues

finalLocalValues

currentNode

currentTree

currentInput

Constructor Detail

Analysis

Analysis

Analysis

Method Detail

getCurrentTree

setCurrentTree

getTransferFunction

getTypes

getEnv

performAnalysis

performAnalysisBlock

propagateStoresTo

updateNodeValues

callTransferFunction

init

addToWorklist

addStoreBefore

getInput

getInputBefore

getStoreBefore

readFromStore

isRunning

getValue

getNodeValues

getValue

getNodesForTree

getContainingMethod

getContainingClass

getReturnStatementStores

getResult

getRegularExitStore

getExceptionalExitStore