Module signature InputSig

Extra data-flow steps needed for lambda flow analysis.

Holds if flow is allowed to pass from parameter p and back to itself as a side-effect, resulting in a summary from p to itself.

Holds if values stored inside content c are cleared at node n. For example, any value stored inside f is cleared at the pre-update node associated with x in x.f = newValue.

Holds if t1 and t2 are compatible types.

Holds if the value that is being tracked is expected to be stored inside content c at node n.

Gets the node corresponding to e.

Holds if access paths with c at their head always should be tracked at high precision. This disables adaptive access path precision for such access paths. This may be beneficial for content that indicates an element of an array or container.

Gets an additional term that is added to the join and branch computations to reflect an additional forward or backwards branching factor that is not taken into account when calculating the (virtual) dispatch cost.

Gets a node that can read the value returned from call with return kind kind.

Gets the content approximation for content c.

Gets the second-level scope containing the node n, if any.

Holds if fieldFlowBranchLimit should be ignored for flow going into/out of c.

Holds if the nodes in nr are unreachable when the call context is call.

Holds if data can flow from node1 to node2 through a non-local step that does not follow a call edge. For example, a step through a global variable.

Holds if call is a lambda call of kind kind where receiver is the lambda expression.

Holds if creation is an expression that creates a lambda of kind kind for c.

Holds if the value of node2 is given by node1.

Holds if the set of viable implementations that can be called by call might be improved by knowing the call context.

Holds if n should never be skipped over in the PathGraph and in path explanations.

Holds if the parameter position ppos matches the argument position apos.

Holds if data can flow from node1 to node2 via a read of c. Thus, node1 references an object with a content c.getAReadContent() whose value ends up in node2.

Holds if there is a simple local flow step from node1 to node2. These are the value-preserving intra-callable flow steps.

Holds if data can flow from node1 to node2 via a store into c. Thus, node2 references an object with a content c.getAStoreContent() that contains the value of node1.

Holds if t1 is strictly stronger than t2. That is, t1 is a strict subtype of t2.

Holds if the data-flow step from node1 to node2 can be used to determine where side-effects may return from a callable.

Gets a viable implementation of the target of the given Call.

Gets a viable dispatch target of call in the context ctx. This is restricted to those calls for which a context might make a difference.

A content approximation. A content approximation corresponds to one or more Contents, and is used to provide an in-between level of precision for pruning.

An entity that represents a set of Contents.

A second-level control-flow scope in a callable.

A type for a data flow node.

A node in the data flow graph.

A set of Nodes in a DataFlowCallable.

A node in the data flow graph that represents an output of a call.

A node in the data flow graph representing the value of some other node after an operation that might have changed its state. A typical example is an argument, which may have been modified by the callee. For example, consider the following code calling a setter method: x.setFoo(y); The post-update node for the argument node x is the node representing the value of x after the field foo has been updated.