Class AbstractInterpretationVisitor<Domain, OtherInfo, Config>Abstract
Type Parameters
- Domain extends AnyAbstractDomain
- OtherInfo = NoInfo
- Config extends AbsintVisitorConfiguration<Domain, OtherInfo> = AbsintVisitorConfiguration<Domain, OtherInfo>
Hierarchy (View Summary)
- SemanticCfgGuidedVisitor<
OtherInfo,
ControlFlowInformation,
NormalizedAst<OtherInfo>,
DataflowGraph,
Config & { defaultVisitingOrder: "forward"; defaultVisitingType: "exit" },
>- AbstractInterpretationVisitor
Hierarchy-Diagram
Index
Constructors
Properties
Methods
Constructors
constructor
- new AbstractInterpretationVisitor<
Domain extends AnyAbstractDomain,
OtherInfo = object,
Config extends
AbsintVisitorConfiguration<Domain, OtherInfo> = AbsintVisitorConfiguration<
Domain,
OtherInfo,
>,
>(
config: Config,
): AbstractInterpretationVisitor<Domain, OtherInfo, Config>Type Parameters
- Domain extends AnyAbstractDomain
- OtherInfo = object
- Config extends AbsintVisitorConfiguration<Domain, OtherInfo> = AbsintVisitorConfiguration<Domain, OtherInfo>
Parameters
- config: Config
Returns AbstractInterpretationVisitor<Domain, OtherInfo, Config>
Properties
Protected Readonlyconfig
Protected Readonlytrace
The abstract trace of the abstract interpretation visitor mapping node IDs to the abstract state at the respective node.
Protected Readonlyvisited
Methods
Protected Abstracteval
- evalAccessCall(
call: DataflowGraphVertexFunctionCall,
state: StateAbstractDomain<Domain>,
): StateAbstractDomain<Domain>Evaluates any access operation call visited by the abstract interpretation visitor by applying the abstract semantics of the access operation to the current abstract stat (e.g. for
$,[,[[, ...).Parameters
- call: DataflowGraphVertexFunctionCall
The data flow vertex of the access operation to evaluate
- state: StateAbstractDomain<Domain>
The current abstract state before the evaluation of the access operation
Returns StateAbstractDomain<Domain>
The abstract state after applying the abstract semantics of the access operation
- call: DataflowGraphVertexFunctionCall
Protected Abstracteval
- evalFunctionCall(
call: DataflowGraphVertexFunctionCall,
state: StateAbstractDomain<Domain>,
): StateAbstractDomain<Domain>Evaluates any function call visited by the abstract interpretation visitor by applying the abstract semantics of the function call to the current abstract state.
Parameters
- call: DataflowGraphVertexFunctionCall
The data flow vertex of the function call to evaluate
- state: StateAbstractDomain<Domain>
The current abstract state before the evaluation of the function call
Returns StateAbstractDomain<Domain>
The abstract state after applying the abstract semantics of the function call
- call: DataflowGraphVertexFunctionCall
Protected Abstracteval
- evalReplacementCall(
call: DataflowGraphVertexFunctionCall,
target: NodeId,
source: NodeId,
state: StateAbstractDomain<Domain>,
): StateAbstractDomain<Domain>Evaluates any replacement function call visited by the abstract interpretation visitor by applying the abstract semantics of the replacement call to the current abstract state (e.g. for
$<-,[<-,names<-, ...).Parameters
- call: DataflowGraphVertexFunctionCall
The data flow vertex of the replacement call to evaluate
- target: NodeId
The node ID of the assigned expression of the replacement call
- source: NodeId
The node ID of the assignment target of the replacement call
- state: StateAbstractDomain<Domain>
The current abstract state before the evaluation of the replacement call
Returns StateAbstractDomain<Domain>
The abstract state after applying the abstract semantics of the replacement call
- call: DataflowGraphVertexFunctionCall
get
Gets the inferred abstract state at the location of a specific AST node. This requires that the abstract interpretation visitor has been completed, or at least started.
Parameters
- id: undefined | NodeId
The ID of the node to get the abstract state at
Returns undefined | StateAbstractDomain<Domain>
The abstract state at the node, or
undefinedif the node has no abstract state (i.e. the node has not been visited or is unreachable).- id: undefined | NodeId
get
Gets the inferred abstract trace mapping AST nodes to the inferred abstract state at the respective node.
Returns ReadonlyMap<NodeId, StateAbstractDomain<Domain>>
The inferred abstract trace of the program
get
- getAbstractValue(
id: undefined | NodeId | RNode<ParentInformation & OtherInfo>,
state?: StateAbstractDomain<Domain>,
): undefined | DomainResolves the inferred abstract value of an AST node. This requires that the abstract interpretation visitor has been completed, or at least started.
Parameters
- id: undefined | NodeId | RNode<ParentInformation & OtherInfo>
The ID of the node to get the inferred value for
Optionalstate: StateAbstractDomain<Domain>An optional state abstract domain used to resolve the inferred abstract value (defaults to the state at the requested node)
Returns undefined | Domain
The inferred abstract value of the node, or
undefinedif no value was inferred for the node - id: undefined | NodeId | RNode<ParentInformation & OtherInfo>
Protectedget
Get the control flow vertex for the given node id or fail if it does not exist.
Parameters
- id: NodeId
Returns undefined | CfgSimpleVertex
Protectedget
Get the dataflow graph vertex for the given id
Parameters
- id: NodeId
Returns undefined | DataflowGraphVertexArgument
get
Gets the inferred abstract state at the end of the program (exit nodes of the control flow graph). This requires that the abstract interpretation visitor has been completed, or at least started.
Returns StateAbstractDomain<Domain>
The inferred abstract state at the end of the program
Protectedget
A helper function to get the normalized AST node for the given id or fail if it does not exist.
Parameters
- id: undefined | NodeId
Returns undefined | RNode<OtherInfo & ParentInformation>
Protectedget
Protectedget
Protectedget
Protectedis
We only perform widening at
for,while, orrepeatloops with more than one incoming CFG edgeParameters
- nodeId: NodeId
Returns boolean
Protectedon
ProtectedThis event triggers for every subsetting call, i.e., for every call to
[[,[, or$.Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to any of the
*applyfunctions.For example,
lapplyinlapply(1:10, function(x) { x + 1 }).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
- onAssignmentCall(
__namedParameters: {
call: DataflowGraphVertexFunctionCall;
source?: NodeId;
target?: NodeId;
},
): voidProtectedThis event triggers for every assignment call, i.e., for every call to
<-or=that assigns a value to a variable.For example, this triggers for
<-inx <- 42orassigninassign("x", 42). This also triggers for thedata.tableassign:=active within subsetting calls, e.g.,DT[, x := 42].Please be aware that replacements (e.g. assignments with a function call on the target side) like
names(x) <- 3are subject to SemanticCfgGuidedVisitor#onReplacementCall|onReplacementCallinstead.Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall; source?: NodeId; target?: NodeId }
Returns void
Protectedon
Parameters
- node: CfgBasicBlockVertex
Returns void
Protectedon
ProtectedThis event triggers for every function call that is not handled by a specific overload, and hence may be a function that targets a user-defined function. In a way, these are functions that are named, but flowR does not specifically care about them (currently) wrt. to their dataflow impact.
Use SemanticCfgGuidedVisitor#getOrigins|
getOriginsto get the origins of the call.For example, this triggers for
foo(x)infoo <- function(x) { x + 1 }
foo(x)This explicitly will not trigger for scenarios in which the function has no name (i.e., if it is anonymous). For such cases, you may rely on the SemanticCfgGuidedVisitor#onUnnamedCall|
onUnnamedCallevent. The main reason for this separation is part of flowR's handling of these functions, as anonymous calls cannot be resolved using the active environment.Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis function is responsible for dispatching the appropriate event based on a given dataflow vertex. The default serves as a backend for the event functions, but you may overwrite and extend this function at will.
Parameters
- call: DataflowGraphVertexFunctionCall
- origin: string
Returns void
See
onDispatchFunctionCallOrigins for the aggregation in case the function call target is ambiguous.
Protectedon
- onDispatchFunctionCallOrigins(
call: DataflowGraphVertexFunctionCall,
origins: readonly string[],
): voidProtectedGiven a function call that has multiple targets (e.g., two potential built-in definitions). This function is responsible for calling onDispatchFunctionCallOrigin for each of the origins, and aggregating their results (which is just additive by default). If you want to change the behavior in case of multiple potential function definition targets, simply overwrite this function with the logic you desire.
Parameters
- call: DataflowGraphVertexFunctionCall
- origins: readonly string[]
Returns void
Protectedon
Parameters
- node: CfgEndMarkerVertex
Returns void
Protectedon
ProtectedThis event triggers for every call to the
evalfunction.For example,
evalineval(parse(text = "x + 1")).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every expression list - implicit or explicit, but not for the root program (see SemanticCfgGuidedVisitor#onProgram|
onProgramfor that).For example, this triggers for the expression list created by
{and}inìf (TRUE) { x <- 1; y <- 2; }. But also for the implicit expression listx <- x + 1infor(x in 1:10) x <- x + 1.Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
Parameters
- node: CfgExpressionVertex
Returns void
Protectedon
- onForLoopCall(
_data: {
body: FunctionArgument;
call: DataflowGraphVertexFunctionCall;
variable: FunctionArgument;
vector: FunctionArgument;
},
): voidProtectedThis event triggers for every call to the
forloop function, which is used to implement theforloop control flow.For example, this triggers for
forinfor(i in 1:10) { print(i) }.More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: {
body: FunctionArgument;
call: DataflowGraphVertexFunctionCall;
variable: FunctionArgument;
vector: FunctionArgument;
}
Returns void
- _data: {
Protectedon
- onFunctionDefinition(
_data: {
parameters?: readonly NodeId[];
vertex: DataflowGraphVertexFunctionDefinition;
},
): voidCalled for every anonymous function definition.
For example,
function(x) { x + 1 }inlapply(1:10, function(x) { x + 1 }).Parameters
- _data: {
parameters?: readonly NodeId[];
vertex: DataflowGraphVertexFunctionDefinition;
}
Returns void
- _data: {
Protectedon
ProtectedThis event triggers for every call to the
getfunction, which is used to access variables in the global environment.For example,
getinget("x").Please be aware, that with flowR resolving the
getduring the dataflow analysis, this may very well trigger a SemanticCfgGuidedVisitor#onVariableUse|onVariableUseevent as well.Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
- onIfThenElseCall(
_data: {
call: DataflowGraphVertexFunctionCall;
condition: undefined | NodeId;
else: undefined | NodeId;
then: undefined | NodeId;
},
): voidProtectedThis event triggers for every call to the
iffunction, which is used to implement theif-then-elsecontrol flow.Parameters
- _data: {
call: DataflowGraphVertexFunctionCall;
condition: undefined | NodeId;
else: undefined | NodeId;
then: undefined | NodeId;
}
Returns void
- _data: {
Protectedon
ProtectedThis event triggers for every call to a function which loads a library.
For example,
libraryinlibrary(dplyr).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call that (to the knowledge of flowr) constructs a (new) list.
For example, this triggers for
listinlist(1, 2, 3).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
Called for every constant logical value in the program.
For example,
TRUEinif(TRUE) { ... }.Parameters
- _data: { node: RLogical; vertex: DataflowGraphVertexValue }
Returns void
Protectedon
- onNullConstant(
_data: {
node: RSymbol<OtherInfo & ParentInformation, "NULL">;
vertex: DataflowGraphVertexValue;
},
): voidCalled for every occurrence of a
NULLin the program.For other symbols that are not referenced as a variable, see SemanticCfgGuidedVisitor#onSymbolConstant|
onSymbolConstant.Parameters
- _data: {
node: RSymbol<OtherInfo & ParentInformation, "NULL">;
vertex: DataflowGraphVertexValue;
}
Returns void
- _data: {
Protectedon
Called for every constant number value in the program.
For example,
42inprint(42).Parameters
- _data: { node: RNumber; vertex: DataflowGraphVertexValue }
Returns void
Protectedon
- onPipeCall(
_data: {
call: DataflowGraphVertexFunctionCall;
lhs?: FunctionArgument;
rhs?: FunctionArgument;
},
): voidProtectedThis event triggers for every call to R's pipe operator, i.e., for every call to
|>.Parameters
- _data: {
call: DataflowGraphVertexFunctionCall;
lhs?: FunctionArgument;
rhs?: FunctionArgument;
}
Returns void
- _data: {
Protectedon
ProtectedThis event is called for the root program node, i.e., the program that is being analyzed.
Parameters
- _data: RExpressionList<OtherInfo>
Returns void
Protectedon
ProtectedThis event triggers for every call to the
quotefunction, which is used to quote expressions.For example,
quoteinquote(x + 1).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to the
repeatloop function, which is used to implement therepeatloop control flow.For example, this triggers for
repeatinrepeat { i <- i + 1; if(i >= 10) break }.More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { body: FunctionArgument; call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
- onReplacementCall(
__namedParameters: {
call: DataflowGraphVertexFunctionCall;
source?: NodeId;
target?: NodeId;
},
): voidProtectedThis event triggers for every call to a function that replaces a value in a container, such as
names(x) <- 3.This is different from SemanticCfgGuidedVisitor#onAssignmentCall|
onAssignmentCallin that it does not assign a value to a variable, but rather replaces a value in a container.For example, this triggers for
namesinnames(x) <- 3, but not forx <- 3.More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall; source?: NodeId; target?: NodeId }
Returns void
Protectedon
ProtectedThis event triggers for every call to the
rmfunction, which is used to remove variables from the environment.For example,
rminrm(x).Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to the
sourcefunction.For example,
sourceinsource("script.R").By default, this does not provide the resolved source file. Yet you can access the DataflowGraph to ask for sourced files.
More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to a special binary operator, i.e., every binary function call that starts and ends with a
%sign.For example, this triggers for
%in%inx %in% y.More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
Parameters
- node: CfgStatementVertex
Returns void
Protectedon
Called for every constant string value in the program.
For example,
"Hello World"inprint("Hello World").Parameters
- _data: { node: RString; vertex: DataflowGraphVertexValue }
Returns void
Protectedon
Called for every constant symbol value in the program.
For example,
fooinlibrary(foo)orainl$a. This most likely happens as part of non-standard-evaluation, i.e., the symbol is not evaluated to a value, but used as a symbol in and of itself.Please note, that due to its special behaviors,
NULLis handled in SemanticCfgGuidedVisitor#onNullConstant|onNullConstantand not here.Parameters
- _data: { node: RSymbol; vertex: DataflowGraphVertexValue }
Returns void
Protectedon
ProtectedThis event triggers for every anonymous call within the program.
For example,
(function(x) { x + 1 })(42)or the second call ina()().This is separate from SemanticCfgGuidedVisitor#onDefaultFunctionCall|
onDefaultFunctionCallwhich is used for named function calls that do not trigger any of these events. The main differentiation for these calls is that you may not infer their semantics from any name alone and probably have to rely on SemanticCfgGuidedVisitor#getOrigins|getOriginsto get more information.Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
Called for every variable that is written within the program. You can use getOrigins to get the origins of the variable.
For example,
xinx <- 42orxinassign("x", 42). See SemanticCfgGuidedVisitor#onAssignmentCall for the assignment call. This event handler also provides you with information on the source.Parameters
- __namedParameters: { vertex: DataflowGraphVertexVariableDefinition }
Returns void
Protectedon
Called for every variable that is read within the program. You can use getOrigins to get the origins of the variable.
For example,
xinprint(x).Parameters
- _data: { vertex: DataflowGraphVertexUse }
Returns void
Protectedon
ProtectedThis event triggers for every call that (to the knowledge of flowr) constructs a (new) vector.
For example, this triggers for
cinc(1, 2, 3).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
Parameters
- node: NodeId
Returns void
Protectedon
- onWhileLoopCall(
_data: {
body: FunctionArgument;
call: DataflowGraphVertexFunctionCall;
condition: FunctionArgument;
},
): voidProtectedThis event triggers for every call to the
whileloop function, which is used to implement thewhileloop control flow.For example, this triggers for
whileinwhile(i < 10) { i <- i + 1 }.More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: {
body: FunctionArgument;
call: DataflowGraphVertexFunctionCall;
condition: FunctionArgument;
}
Returns void
- _data: {
Protectedshould
- shouldContinueVisiting(
wideningPoint: CfgSimpleVertex,
oldState: StateAbstractDomain<Domain>,
): booleanChecks whether to continue visiting the control flow graph after a widening point. By default, we only continue visiting if the widening point is visited for the first time or the abstract state at the widening point changed.
Parameters
- wideningPoint: CfgSimpleVertex
- oldState: StateAbstractDomain<Domain>
Returns boolean
Protectedshould
Checks whether a control flow graph vertex should be skipped during visitation. By default, we only process vertices of leaf nodes and exit vertices (no entry nodes of complex nodes).
Parameters
- vertex: CfgSimpleVertex
Returns boolean
Protectedshould
Whether widening should be performed at a widening point. By default, we perform widening when the number of visitation of the widening point reaches the widening threshold of the config.
Parameters
- wideningPoint: CfgSimpleVertex
Returns boolean
start
Start the visiting process.
Returns void
Protectedstart
Parameters
- start: readonly NodeId[]
Returns void
Protectedvisit
Parameters
Returns void
Protectedvisit
ProtectedSee DataflowAwareCfgGuidedVisitor#visitFunctionCall for the base implementation.
This function is called for every function call in the program and dispatches the appropriate event. You probably do not have to overwrite it and just use SemanticCfgGuidedVisitor#onUnnamedCall|
onUnnamedCallfor anonymous calls, or SemanticCfgGuidedVisitor#onDispatchFunctionCallOrigins|onDispatchFunctionCallOriginsfor named calls (or just overwrite the events you are interested in directly).Parameters
- vertex: DataflowGraphVertexFunctionCall
Returns void
Protectedvisit
ProtectedSee DataflowAwareCfgGuidedVisitor#visitFunctionDefinition for the base implementation.
This function is called for every function definition in the program and dispatches the appropriate event. You probably do not have to overwrite it and just use SemanticCfgGuidedVisitor#onFunctionDefinition|
onFunctionDefinitioninstead.Parameters
Returns void
Protectedvisit
call this function to indicate that a node is to be considered visited.
Parameters
- vertexId: NodeId
Returns boolean
trueif the node was not visited before,falseotherwise
Protectedvisit
ProtectedSee DataflowAwareCfgGuidedVisitor#visitUnknown for the base implementation. This function is called for every unknown vertex in the program. It dispatches the appropriate event based on the type of the vertex. In case you have to overwrite this function please make sure to still call this implementation to get a correctly working SemanticCfgGuidedVisitor#onProgram|
onProgram.Parameters
- vertex: CfgStatementVertex | CfgExpressionVertex
Returns void
Protectedvisit
See DataflowAwareCfgGuidedVisitor#visitValue for the base implementation. This now dispatches the value to the appropriate event handler based on its type.
Parameters
Returns void
Protectedvisit
ProtectedSee DataflowAwareCfgGuidedVisitor#visitVariableDefinition for the base implementation.
This function is called for every variable definition in the program and dispatches the appropriate event. You probably do not have to overwrite it and just use SemanticCfgGuidedVisitor#onVariableDefinition|
onVariableDefinitioninstead.Parameters
Returns void
Protectedvisit
ProtectedSee DataflowAwareCfgGuidedVisitor#visitVariableUse for the base implementation.
This function is called for every use of a variable in the program and dispatches the appropriate event. You probably do not have to overwrite it and just use SemanticCfgGuidedVisitor#onVariableUse|
onVariableUseinstead.Parameters
- vertex: DataflowGraphVertexUse
Returns void
A control flow graph visitor to perform abstract interpretation.
However, the visitor does not yet support inter-procedural abstract interpretation and abstract condition semantics.