Class DataFrameShapeInferenceVisitor<OtherInfo, ControlFlow, Ast, Dfg, Config>
Type Parameters
- OtherInfo = NoInfo
- ControlFlow extends ControlFlowInformation = ControlFlowInformation
- Ast extends NormalizedAst<OtherInfo & AbstractInterpretationInfo> = NormalizedAst<OtherInfo & AbstractInterpretationInfo>
- Dfg extends DataflowGraph = DataflowGraph
- Config extends DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg> = DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg>
Hierarchy (View Summary)
- SemanticCfgGuidedVisitor<
OtherInfo & AbstractInterpretationInfo,
ControlFlow,
Ast,
Dfg,
Config & { defaultVisitingOrder: "forward"; defaultVisitingType: "exit" },
>- DataFrameShapeInferenceVisitor
Hierarchy-Diagram
Index
Constructors
Properties
Methods
Constructors
constructor
- new DataFrameShapeInferenceVisitor<
OtherInfo = object,
ControlFlow extends
ControlFlowInformation<CfgSimpleVertex> = ControlFlowInformation<
CfgSimpleVertex,
>,
Ast extends
NormalizedAst<
OtherInfo & AbstractInterpretationInfo,
RNode<OtherInfo & AbstractInterpretationInfo & ParentInformation>,
> = NormalizedAst<
OtherInfo & AbstractInterpretationInfo,
RNode<OtherInfo & AbstractInterpretationInfo & ParentInformation>,
>,
Dfg extends
DataflowGraph<DataflowGraphVertexInfo, DataflowGraphEdge> = DataflowGraph<
DataflowGraphVertexInfo,
DataflowGraphEdge,
>,
Config extends
DataFrameShapeInferenceVisitorConfiguration<
OtherInfo,
ControlFlow,
Ast,
Dfg,
> = DataFrameShapeInferenceVisitorConfiguration<
OtherInfo,
ControlFlow,
Ast,
Dfg,
>,
>(
config: Config,
): DataFrameShapeInferenceVisitor<OtherInfo, ControlFlow, Ast, Dfg, Config>Type Parameters
- OtherInfo = object
- ControlFlow extends ControlFlowInformation<CfgSimpleVertex> = ControlFlowInformation<CfgSimpleVertex>
- Ast extends NormalizedAst<
OtherInfo & AbstractInterpretationInfo,
RNode<OtherInfo & AbstractInterpretationInfo & ParentInformation>,
> = NormalizedAst<
OtherInfo & AbstractInterpretationInfo,
RNode<OtherInfo & AbstractInterpretationInfo & ParentInformation>,
> - Dfg extends DataflowGraph<DataflowGraphVertexInfo, DataflowGraphEdge> = DataflowGraph<DataflowGraphVertexInfo, DataflowGraphEdge>
- Config extends DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg> = DataFrameShapeInferenceVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg>
Parameters
- config: Config
Returns DataFrameShapeInferenceVisitor<OtherInfo, ControlFlow, Ast, Dfg, Config>
Methods
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
Protectedget
- getNormalizedAst(
id: undefined | NodeId,
):
| undefined
| RNode<OtherInfo & AbstractInterpretationInfo & ParentInformation>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 & AbstractInterpretationInfo & ParentInformation>
Protectedget
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 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
- _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
- 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: 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
- _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
Called for every constant logical value in the program.
For example,
TRUEinif(TRUE) { ... }.Parameters
- _data: { node: RLogical; vertex: DataflowGraphVertexValue }
Returns void
Protectedon
Parameters
- _node: CfgMidMarkerVertex
Returns void
Protectedon
- onNullConstant(
_data: {
node: RSymbol<
OtherInfo & AbstractInterpretationInfo & 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 & AbstractInterpretationInfo & 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
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 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: undefined | NodeId;
target: undefined | 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: undefined | NodeId;
target: undefined | NodeId;
}
Returns void
- __namedParameters: {
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 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
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
- _data: { vertex: 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: {
start
Start the visiting process.
Returns void
Protectedstart
Parameters
- start: readonly NodeId[]
Returns void
Protectedvisit
- visitDataflowNode(
vertex:
| CfgStatementVertex
| CfgExpressionVertex
| CfgMidMarkerVertex
| CfgEndMarkerVertex,
): voidParameters
- vertex:
| CfgStatementVertex
| CfgExpressionVertex
| CfgMidMarkerVertex
| CfgEndMarkerVertex
Returns void
- vertex:
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
- nodeId: 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