Class DataFrameShapeInferenceVisitor
Hierarchy (View Summary)
- AbstractInterpretationVisitor<
DataFrameDomain,
DataFrameShapeInferenceConfiguration,
>- DataFrameShapeInferenceVisitor
Hierarchy-Diagram
Index
Constructors
Properties
Accessors
Methods
Constructors
constructor
- new DataFrameShapeInferenceVisitor(
__namedParameters: DataFrameShapeInferenceConfiguration,
): DataFrameShapeInferenceVisitorParameters
- __namedParameters: DataFrameShapeInferenceConfiguration
Returns DataFrameShapeInferenceVisitor
Properties
Protected Readonlyconfig
defaultVisitingOrder: "forward";
defaultVisitingType: "exit";
}
Protected Readonlytrace
The abstract trace of the abstract interpretation visitor mapping node IDs to the abstract state at the respective node.
Protected Readonlyvisited
Accessors
current
Returns StateAbstractDomain<Domain>
Methods
get
- getAbstractOperations(
id: NodeId | undefined,
): Readonly<
DataFrameOperations<
| "unknown"
| "join"
| "read"
| "create"
| "accessCols"
| "accessRows"
| "assignCols"
| "assignRows"
| "setColNames"
| "addCols"
| "addRows"
| "removeCols"
| "removeRows"
| "concatCols"
| "concatRows"
| "subsetCols"
| "subsetRows"
| "filterRows"
| "mutateCols"
| "groupBy"
| "summarize"
| "identity",
>,
>Gets the mapped abstract data frame operations for an AST node (this only includes direct function calls, replacement calls, or access operations). This requires that the abstract interpretation visitor has been completed, or at least started.
Parameters
- id: NodeId | undefined
The ID of the node to get the mapped abstract operations for
Returns Readonly<
DataFrameOperations<
| "unknown"
| "join"
| "read"
| "create"
| "accessCols"
| "accessRows"
| "assignCols"
| "assignRows"
| "setColNames"
| "addCols"
| "addRows"
| "removeCols"
| "removeRows"
| "concatCols"
| "concatRows"
| "subsetCols"
| "subsetRows"
| "filterRows"
| "mutateCols"
| "groupBy"
| "summarize"
| "identity",
>,
>The mapped abstract data frame operations for the node, or
undefinedif no abstract operation was mapped for the node or storing mapped abstract operations is disabled via the visitor config. - id: NodeId | undefined
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: NodeId | undefined
The ID of the node to get the abstract state at
Returns StateAbstractDomain<DataFrameDomain> | undefined
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: NodeId | undefined
get
Gets the inferred abstract trace mapping AST nodes to the inferred abstract state at the respective node.
Returns ReadonlyMap<NodeId, StateAbstractDomain<DataFrameDomain>>
The inferred abstract trace of the program
get
- getAbstractValue(
id: NodeId | RNode<ParentInformation> | undefined,
state?: StateAbstractDomain<DataFrameDomain>,
): DataFrameDomain | undefinedResolves the inferred abstract value of an AST node. This requires that the abstract interpretation visitor has been completed, or at least started.
Parameters
- id: NodeId | RNode<ParentInformation> | undefined
The ID of the node to get the inferred value for
Optionalstate: StateAbstractDomain<DataFrameDomain>An optional state abstract domain used to resolve the inferred abstract value (defaults to the state at the requested node)
Returns DataFrameDomain | undefined
The inferred abstract value of the node, or
undefinedif no value was inferred for the node - id: NodeId | RNode<ParentInformation> | undefined
Protectedget
Protectedget
Get the dataflow graph vertex for the given id
Parameters
- id: NodeId
Returns DataflowGraphVertexArgument | undefined
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<DataFrameDomain>
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: NodeId | undefined
Returns RNode<object & ParentInformation> | undefined
Protectedget
Protectedget
Protectedget
Protectedis
We only perform widening at
for,while, orrepeatloops with more than one ingoing 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
- _data: { 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 call to
breakto exit a loop.For example, this triggers for
breakinrepeat { break }.More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
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
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
- onDispatchFunctionCallOrigin(
call: DataflowGraphVertexFunctionCall,
origin: BuiltInProcName,
): voidProtectedThis 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: BuiltInProcName
Returns void
See
onDispatchFunctionCallOrigins for the aggregation in case the function call target is ambiguous.
Protectedon
- onDispatchFunctionCallOrigins(
call: DataflowGraphVertexFunctionCall,
origins: readonly BuiltInProcName[],
): 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 BuiltInProcName[]
Returns void
Protectedon
Parameters
- node: CfgMarkerVertex
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
- _data: { 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
ProtectedThis event triggers for every function call that is not a condition, loop, assignment, replacement call, or access operation.
For example, this triggers for
data.frameinx <- data.frame(id = 1:5, name = letters[1:5]).This bundles all function calls that are no conditions, loops, assignments, replacement calls, and access operations.
Parameters
- __namedParameters: { call: DataflowGraphVertexFunctionCall }
Returns void
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
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
- onIfThenElseCall(
_data: {
call: DataflowGraphVertexFunctionCall;
condition: NodeId | undefined;
no: NodeId | undefined;
yes: NodeId | undefined;
},
): voidProtectedThis event triggers for every call to the
iffunction, which is used to implement theif-then-elsecontrol flow.Parameters
- _data: {
call: DataflowGraphVertexFunctionCall;
condition: NodeId | undefined;
no: NodeId | undefined;
yes: NodeId | undefined;
}
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
- _data: { 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
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to a function that performs a local call, such as
local.For example, this triggers for
localinlocal({ x <- 1; y <- 2; x + y }).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { 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<object & 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<object & 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<object>
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
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to
Recall, which is used to recall the function closure (usually in recursive functions).Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to a function that registers a hook, such as
on.exit.For example, this triggers for
on.exitinon.exit(print("exiting function")).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { 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;
},
): voidThis 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
returnto explicitly return a value in a function.For example, this triggers for
returninf <- function() { return(42) }.More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
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
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to a function that performs an S3-like dispatch.
For example, this triggers for
UseMethodinUseMethod("print").Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to a function that performs an S3-like next dispatch.
For example, this triggers for
NextMethod.Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to a function that performs an S7 dispatch, such as
S7_dispatch.Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to a function that creates a new S7 generic, such as
new_generic.Parameters
- _data: { 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
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
- onSpecialBinaryOpCall(
_data: {
call: DataflowGraphVertexFunctionCall;
lhs?: FunctionArgument;
rhs?: FunctionArgument;
},
): voidProtectedThis 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
- _data: {
call: DataflowGraphVertexFunctionCall;
lhs?: FunctionArgument;
rhs?: FunctionArgument;
}
Returns void
- _data: {
Protectedon
Parameters
- node: CfgStatementVertex
Returns void
Protectedon
ProtectedThis event triggers for every call to the
stopfunction.For example, this triggers for
stopinstop().More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
Returns void
Protectedon
ProtectedThis event triggers for every call to the
stopifnotfunction.For example, this triggers for
stopifnotinstopifnot(x > 0).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
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 call the
tryfunction, which is used to catch possible errors.For example, this triggers for
tryintry(stop("error")).More specifically, this relates to the corresponding BuiltInProcessorMapper handler.
Parameters
- _data: { call: DataflowGraphVertexFunctionCall }
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
- _data: { 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
- _data: { 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: {
remove
Parameters
- node: NodeId
Returns void
Protectedshould
Checks whether a control flow graph vertex should be skipped during visitation. By default, we only process entry vertices of widening points, vertices of leaf nodes, and exit vertices (no entry nodes of complex nodes).
Parameters
- vertex: CfgVertex
Returns boolean
Protectedshould
Whether widening should be performed at a widening point. By default, we perform widening when the number of visits of the widening point reaches the widening threshold of the config.
Parameters
- wideningPoint: CfgVertex
Returns boolean
start
Start the visiting process.
Returns void
Protectedstart
Parameters
- start: readonly NodeId[]
Returns void
update
Parameters
- node: NodeId
- value: DataFrameDomain
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
The control flow graph visitor to infer the shape of data frames using abstract interpretation