@eagleoutice/flowr 2.2.14 → 2.2.16

package/control-flow/cfg-simplification.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultCfgSimplificationOrder = void 0;
+exports.DefaultCfgSimplificationOrder = exports.CfgSimplificationPasses = void 0;
 exports.simplifyControlFlowInformation = simplifyControlFlowInformation;
-const simple_visitor_1 = require("./simple-visitor");
 const cfg_to_basic_blocks_1 = require("./cfg-to-basic-blocks");
-const CfgSimplificationPasses = {
+const simple_visitor_1 = require("./simple-visitor");
+const cfg_dead_code_1 = require("./cfg-dead-code");
+exports.CfgSimplificationPasses = {
     'unique-cf-sets': uniqueControlFlowSets,
+    'analyze-dead-code': cfg_dead_code_1.cfgAnalyzeDeadCode,
     'remove-dead-code': cfgRemoveDeadCode,
     'to-basic-blocks': toBasicBlocks
 };
@@ -18,25 +20,17 @@ exports.DefaultCfgSimplificationOrder = [
  * Simplify the control flow information by applying the given passes.
  * This may reduce the vertex count, in- and outgoing edges, entry and exit points, etc.
  */
-function simplifyControlFlowInformation(cfg, passes = exports.DefaultCfgSimplificationOrder) {
+function simplifyControlFlowInformation(cfg, info, passes = exports.DefaultCfgSimplificationOrder) {
     for (const pass of passes) {
-        const passFn = CfgSimplificationPasses[pass];
-        cfg = passFn(cfg);
+        const passFn = exports.CfgSimplificationPasses[pass];
+        cfg = passFn(cfg, info);
     }
     return cfg;
 }
-function uniqueControlFlowSets(cfg) {
-    return {
-        returns: [...new Set(cfg.returns)],
-        entryPoints: [...new Set(cfg.entryPoints)],
-        exitPoints: [...new Set(cfg.exitPoints)],
-        breaks: [...new Set(cfg.breaks)],
-        nexts: [...new Set(cfg.nexts)],
-        graph: cfg.graph
-    };
-}
-/* currently this does not do work on function definitions */
-function cfgRemoveDeadCode(cfg) {
+/**
+ * removes dead vertices and edges from the control flow graph.
+ */
+function cfgRemoveDeadCode(cfg, _info) {
     // remove every root level node and accompanying vertices that can not be reached from the entry points
     const reachable = new Set();
     (0, simple_visitor_1.visitCfgInOrder)(cfg.graph, cfg.entryPoints, node => {
@@ -49,7 +43,17 @@ function cfgRemoveDeadCode(cfg) {
     }
     return cfg;
 }
-function toBasicBlocks(cfg) {
+function uniqueControlFlowSets(cfg, _info) {
+    return {
+        returns: [...new Set(cfg.returns)],
+        entryPoints: [...new Set(cfg.entryPoints)],
+        exitPoints: [...new Set(cfg.exitPoints)],
+        breaks: [...new Set(cfg.breaks)],
+        nexts: [...new Set(cfg.nexts)],
+        graph: cfg.graph
+    };
+}
+function toBasicBlocks(cfg, _info) {
     return (0, cfg_to_basic_blocks_1.convertCfgToBasicBlocks)(cfg);
 }
 //# sourceMappingURL=cfg-simplification.js.map

package/control-flow/control-flow-graph.d.ts

@@ -67,10 +67,11 @@ export interface CfgBasicBlockVertex extends CfgBaseVertex {
  */
 export type CfgSimpleVertex = CfgStatementVertex | CfgExpressionVertex | CfgBasicBlockVertex | CfgMidMarkerVertex | CfgEndMarkerVertex;
 export declare function equalVertex(a: CfgSimpleVertex, b: CfgSimpleVertex): boolean;
+export declare function isMarkerVertex(vertex: CfgSimpleVertex): vertex is CfgMidMarkerVertex | CfgEndMarkerVertex;
 interface CfgFlowDependencyEdge extends MergeableRecord {
     label: CfgEdgeType.Fd;
 }
-interface CfgControlDependencyEdge extends MergeableRecord {
+export interface CfgControlDependencyEdge extends MergeableRecord {
     label: CfgEdgeType.Cd;
     /** the id which caused the control dependency */
     caused: NodeId;
@@ -166,6 +167,7 @@ export interface ReadOnlyControlFlowGraph {
  */
 export declare class ControlFlowGraph<Vertex extends CfgSimpleVertex = CfgSimpleVertex> implements ReadOnlyControlFlowGraph {
     private readonly rootVertices;
+    /** Nesting-Independent vertex information, mapping the id to the vertex */
     private readonly vertexInformation;
     /** the basic block children map contains a mapping of ids to all vertices that are nested in basic blocks, mapping them to the Id of the block they appear in */
     private readonly bbChildren;

package/control-flow/control-flow-graph.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControlFlowGraph = exports.CfgVertexType = void 0;
 exports.edgeTypeToString = edgeTypeToString;
 exports.equalVertex = equalVertex;
+exports.isMarkerVertex = isMarkerVertex;
 exports.emptyControlFlowInformation = emptyControlFlowInformation;
 const assert_1 = require("../util/assert");
 var CfgVertexType;
@@ -43,6 +44,9 @@ function equalVertex(a, b) {
     }
     return true;
 }
+function isMarkerVertex(vertex) {
+    return vertex.type === CfgVertexType.MidMarker || vertex.type === CfgVertexType.EndMarker;
+}
 /**
  * This class represents the control flow graph of an R program.
  * The control flow may be hierarchical when confronted with function definitions (see {@link CfgSimpleVertex} and {@link CFG#rootVertexIds|rootVertexIds()}).
@@ -55,6 +59,7 @@ function equalVertex(a, b) {
  */
 class ControlFlowGraph {
     rootVertices = new Set();
+    /** Nesting-Independent vertex information, mapping the id to the vertex */
     vertexInformation = new Map();
     /** the basic block children map contains a mapping of ids to all vertices that are nested in basic blocks, mapping them to the Id of the block they appear in */
     bbChildren = new Map();

package/control-flow/dfg-cfg-guided-visitor.d.ts

@@ -1,29 +1,31 @@
-import type { CfgExpressionVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
+import { type CfgBasicBlockVertex, type CfgEndMarkerVertex, type CfgExpressionVertex, type CfgSimpleVertex, type CfgStatementVertex, type ControlFlowInformation } from './control-flow-graph';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { DataflowInformation } from '../dataflow/info';
 import type { DataflowGraphVertexArgument, DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue, DataflowGraphVertexVariableDefinition } from '../dataflow/graph/vertex';
 import type { BasicCfgGuidedVisitorConfiguration } from './basic-cfg-guided-visitor';
 import { BasicCfgGuidedVisitor } from './basic-cfg-guided-visitor';
-export interface DataflowCfgGuidedVisitorConfiguration<Cfg extends ControlFlowInformation = ControlFlowInformation, Dfg extends DataflowInformation = DataflowInformation> extends BasicCfgGuidedVisitorConfiguration<Cfg> {
-    readonly dataflow: Dfg;
+import type { DataflowGraph } from '../dataflow/graph/graph';
+export interface DataflowCfgGuidedVisitorConfiguration<ControlFlow extends ControlFlowInformation = ControlFlowInformation, Dfg extends DataflowGraph = DataflowGraph> extends BasicCfgGuidedVisitorConfiguration<ControlFlow> {
+    readonly dfg: Dfg;
+    readonly defaultVisitingType?: 'entry' | 'exit';
 }
 /**
  * This visitor extends on the {@link BasicCfgGuidedVisitor} by dispatching visitors based on the dataflow graph.
  *
  * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
  */
-export declare class DataflowAwareCfgGuidedVisitor<Cfg extends ControlFlowInformation = ControlFlowInformation, Dfg extends DataflowInformation = DataflowInformation, Config extends DataflowCfgGuidedVisitorConfiguration<Cfg, Dfg> = DataflowCfgGuidedVisitorConfiguration<Cfg, Dfg>> extends BasicCfgGuidedVisitor<Cfg, Config> {
+export declare class DataflowAwareCfgGuidedVisitor<ControlFlow extends ControlFlowInformation = ControlFlowInformation, Dfg extends DataflowGraph = DataflowGraph, Config extends DataflowCfgGuidedVisitorConfiguration<ControlFlow, Dfg> = DataflowCfgGuidedVisitorConfiguration<ControlFlow, Dfg>> extends BasicCfgGuidedVisitor<ControlFlow, Config> {
     /**
      * Get the dataflow graph vertex for the given id
      */
     protected getDataflowGraph(id: NodeId): DataflowGraphVertexArgument | undefined;
     protected onStatementNode(node: CfgStatementVertex): void;
     protected onExpressionNode(node: CfgExpressionVertex): void;
-    private onExprOrStmtNode;
+    protected onEndMarkerNode(node: CfgEndMarkerVertex): void;
+    protected visitDataflowNode(node: Exclude<CfgSimpleVertex, CfgBasicBlockVertex>): void;
     /**
      * called for every cfg vertex that has no corresponding dataflow vertex.
      */
-    protected visitUnknown(_vertex: CfgStatementVertex | CfgExpressionVertex): void;
+    protected visitUnknown(_vertex: Exclude<CfgSimpleVertex, CfgBasicBlockVertex>): void;
     protected visitValue(_val: DataflowGraphVertexValue): void;
     protected visitVariableUse(_use: DataflowGraphVertexUse): void;
     protected visitVariableDefinition(_def: DataflowGraphVertexVariableDefinition): void;

package/control-flow/dfg-cfg-guided-visitor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataflowAwareCfgGuidedVisitor = void 0;
+const control_flow_graph_1 = require("./control-flow-graph");
 const vertex_1 = require("../dataflow/graph/vertex");
 const basic_cfg_guided_visitor_1 = require("./basic-cfg-guided-visitor");
 const assert_1 = require("../util/assert");
@@ -14,18 +15,28 @@ class DataflowAwareCfgGuidedVisitor extends basic_cfg_guided_visitor_1.BasicCfgG
      * Get the dataflow graph vertex for the given id
      */
     getDataflowGraph(id) {
-        return this.config.dataflow.graph.getVertex(id);
+        return this.config.dfg.getVertex(id);
     }
     onStatementNode(node) {
         super.onStatementNode(node);
-        this.onExprOrStmtNode(node);
+        if (this.config.defaultVisitingType !== 'exit' || node.end === undefined) {
+            this.visitDataflowNode(node);
+        }
     }
     onExpressionNode(node) {
         super.onExpressionNode(node);
-        this.onExprOrStmtNode(node);
+        if (this.config.defaultVisitingType !== 'exit' || node.end === undefined) {
+            this.visitDataflowNode(node);
+        }
+    }
+    onEndMarkerNode(node) {
+        super.onEndMarkerNode(node);
+        if (this.config.defaultVisitingType === 'exit') {
+            this.visitDataflowNode(node);
+        }
     }
-    onExprOrStmtNode(node) {
-        const dfgVertex = this.getDataflowGraph(node.id);
+    visitDataflowNode(node) {
+        const dfgVertex = this.getDataflowGraph((0, control_flow_graph_1.isMarkerVertex)(node) ? node.root : node.id);
         if (!dfgVertex) {
             this.visitUnknown(node);
             return;

package/control-flow/extract-cfg.d.ts

@@ -3,18 +3,20 @@ import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/
 import type { DataflowGraph } from '../dataflow/graph/graph';
 import type { ControlFlowInformation } from './control-flow-graph';
 import type { CfgSimplificationPassName } from './cfg-simplification';
+import type { FlowrConfigOptions } from '../config';
 /**
  * Given a normalized AST this approximates the control flow graph of the program.
- * This few is different from the computation of the dataflow graph and may differ,
+ * This view is different from the computation of the dataflow graph and may differ,
  * especially because it focuses on intra-procedural analysis.
  *
  * @param ast             - the normalized AST
+ * @param config          - the Flowr config
  * @param graph           - additional dataflow facts to consider by the control flow extraction
  * @param simplifications - a list of simplification passes to apply to the control flow graph
  *
  * @see {@link extractSimpleCfg} - for a simplified version of this function
  */
-export declare function extractCfg<Info = ParentInformation>(ast: NormalizedAst<Info>, graph?: DataflowGraph, simplifications?: readonly CfgSimplificationPassName[]): ControlFlowInformation;
+export declare function extractCfg<Info = ParentInformation>(ast: NormalizedAst<Info & ParentInformation>, config: FlowrConfigOptions, graph?: DataflowGraph, simplifications?: readonly CfgSimplificationPassName[]): ControlFlowInformation;
 /**
  * Simplified version of {@link extractCfg} that is much quicker, but much simpler!
  */

package/control-flow/extract-cfg.js

@@ -53,17 +53,18 @@ function dataflowCfgFolds(dataflowGraph) {
 }
 /**
  * Given a normalized AST this approximates the control flow graph of the program.
- * This few is different from the computation of the dataflow graph and may differ,
+ * This view is different from the computation of the dataflow graph and may differ,
  * especially because it focuses on intra-procedural analysis.
  *
  * @param ast             - the normalized AST
+ * @param config          - the Flowr config
  * @param graph           - additional dataflow facts to consider by the control flow extraction
  * @param simplifications - a list of simplification passes to apply to the control flow graph
  *
  * @see {@link extractSimpleCfg} - for a simplified version of this function
  */
-function extractCfg(ast, graph, simplifications) {
-    return (0, cfg_simplification_1.simplifyControlFlowInformation)((0, fold_1.foldAst)(ast.ast, graph ? dataflowCfgFolds(graph) : cfgFolds), simplifications);
+function extractCfg(ast, config, graph, simplifications) {
+    return (0, cfg_simplification_1.simplifyControlFlowInformation)((0, fold_1.foldAst)(ast.ast, graph ? dataflowCfgFolds(graph) : cfgFolds), { ast, dfg: graph, config }, simplifications);
 }
 /**
  * Simplified version of {@link extractCfg} that is much quicker, but much simpler!
@@ -72,10 +73,8 @@ function extractSimpleCfg(ast) {
     return (0, fold_1.foldAst)(ast.ast, cfgFolds);
 }
 function cfgLeaf(type) {
-    return (leaf) => {
-        const graph = new control_flow_graph_1.ControlFlowGraph();
-        graph.addVertex({ id: leaf.info.id, type });
-        return { graph, breaks: [], nexts: [], returns: [], exitPoints: [leaf.info.id], entryPoints: [leaf.info.id] };
+    return ({ info: { id } }) => {
+        return { graph: new control_flow_graph_1.ControlFlowGraph().addVertex({ id, type }), breaks: [], nexts: [], returns: [], exitPoints: [id], entryPoints: [id] };
     };
 }
 function cfgBreak(leaf) {
@@ -91,40 +90,41 @@ function identifyMayStatementType(node) {
     return node.info.role === "expr-list-child" /* RoleInParent.ExpressionListChild */ ? control_flow_graph_1.CfgVertexType.Statement : control_flow_graph_1.CfgVertexType.Expression;
 }
 function cfgIfThenElse(ifNode, condition, then, otherwise) {
+    const ifId = ifNode.info.id;
     const graph = new control_flow_graph_1.ControlFlowGraph();
-    graph.addVertex({ id: ifNode.info.id, type: identifyMayStatementType(ifNode), mid: [ifNode.info.id + '-condition'], end: [ifNode.info.id + '-exit'] });
-    graph.addVertex({ id: ifNode.info.id + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: ifNode.info.id });
-    graph.addVertex({ id: ifNode.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: ifNode.info.id });
+    graph.addVertex({ id: ifId, type: identifyMayStatementType(ifNode), mid: [ifId + '-condition'], end: [ifId + '-exit'] });
+    graph.addVertex({ id: ifId + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: ifId });
+    graph.addVertex({ id: ifId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: ifId });
     graph.mergeWith(condition.graph);
     graph.mergeWith(then.graph);
     if (otherwise) {
         graph.mergeWith(otherwise.graph);
     }
     for (const exitPoint of condition.exitPoints) {
-        graph.addEdge(ifNode.info.id + '-condition', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(ifId + '-condition', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entryPoint of then.entryPoints) {
-        graph.addEdge(entryPoint, ifNode.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: ifNode.info.id });
+        graph.addEdge(entryPoint, ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: ifId });
     }
     for (const entryPoint of otherwise?.entryPoints ?? []) {
-        graph.addEdge(entryPoint, ifNode.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifNode.info.id });
+        graph.addEdge(entryPoint, ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
     }
     for (const entryPoint of condition.entryPoints) {
-        graph.addEdge(entryPoint, ifNode.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, ifId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const exit of [...then.exitPoints, ...otherwise?.exitPoints ?? []]) {
-        graph.addEdge(ifNode.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(ifId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     if (!otherwise) {
-        graph.addEdge(ifNode.info.id + '-exit', ifNode.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifNode.info.id });
+        graph.addEdge(ifId + '-exit', ifId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
     }
     return {
         graph,
         breaks: [...then.breaks, ...otherwise?.breaks ?? []],
         nexts: [...then.nexts, ...otherwise?.nexts ?? []],
         returns: [...then.returns, ...otherwise?.returns ?? []],
-        exitPoints: [ifNode.info.id + '-exit'],
-        entryPoints: [ifNode.info.id]
+        exitPoints: [ifId + '-exit'],
+        entryPoints: [ifId]
     };
 }
 function cfgRepeat(repeat, body) {
@@ -144,110 +144,114 @@ function cfgRepeat(repeat, body) {
     return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [repeat.info.id + '-exit'], entryPoints: [repeat.info.id] };
 }
 function cfgWhile(whileLoop, condition, body) {
+    const whileId = whileLoop.info.id;
     const graph = condition.graph;
-    graph.addVertex({ id: whileLoop.info.id, type: identifyMayStatementType(whileLoop), mid: [whileLoop.info.id + '-condition'], end: [whileLoop.info.id + '-exit'] });
-    graph.addVertex({ id: whileLoop.info.id + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: whileLoop.info.id });
-    graph.addVertex({ id: whileLoop.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: whileLoop.info.id });
+    graph.addVertex({ id: whileId, type: identifyMayStatementType(whileLoop), mid: [whileId + '-condition'], end: [whileId + '-exit'] });
+    graph.addVertex({ id: whileId + '-condition', kind: 'condition', type: control_flow_graph_1.CfgVertexType.MidMarker, root: whileId });
+    graph.addVertex({ id: whileId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: whileId });
     graph.mergeWith(body.graph);
     for (const entry of condition.entryPoints) {
-        graph.addEdge(entry, whileLoop.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, whileId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const exit of condition.exitPoints) {
-        graph.addEdge(whileLoop.info.id + '-condition', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(whileId + '-condition', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entry of body.entryPoints) {
-        graph.addEdge(entry, whileLoop.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: whileLoop.info.id });
+        graph.addEdge(entry, whileId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: whileId });
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
-        graph.addEdge(whileLoop.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(whileId, next, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const breakPoint of body.breaks) {
-        graph.addEdge(whileLoop.info.id + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(whileId + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
     // while can break on the condition as well
-    graph.addEdge(whileLoop.info.id + '-exit', whileLoop.info.id + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: whileLoop.info.id });
-    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileLoop.info.id + '-exit'], entryPoints: [whileLoop.info.id] };
+    graph.addEdge(whileId + '-exit', whileId + '-condition', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: whileId });
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileId + '-exit'], entryPoints: [whileId] };
 }
 function cfgFor(forLoop, variable, vector, body) {
+    const forLoopId = forLoop.info.id;
     const graph = variable.graph;
-    graph.addVertex({ id: forLoop.info.id, type: identifyMayStatementType(forLoop), end: [forLoop.info.id + '-exit'], mid: [forLoop.info.id + '-head'] });
+    graph.addVertex({ id: forLoopId, type: identifyMayStatementType(forLoop), end: [forLoopId + '-exit'], mid: [forLoopId + '-head'] });
     graph.mergeWith(vector.graph);
     graph.mergeWith(body.graph);
     for (const entry of vector.entryPoints) {
-        graph.addEdge(entry, forLoop.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, forLoopId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const exit of vector.exitPoints) {
         for (const entry of variable.entryPoints) {
             graph.addEdge(entry, exit, { label: 0 /* CfgEdgeType.Fd */ });
         }
     }
-    graph.addVertex({ id: forLoop.info.id + '-head', type: control_flow_graph_1.CfgVertexType.MidMarker, root: forLoop.info.id, kind: 'head' });
+    graph.addVertex({ id: forLoopId + '-head', type: control_flow_graph_1.CfgVertexType.MidMarker, root: forLoopId, kind: 'head' });
     for (const exit of variable.exitPoints) {
-        graph.addEdge(forLoop.info.id + '-head', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(forLoopId + '-head', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entry of body.entryPoints) {
-        graph.addEdge(entry, forLoop.info.id + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: forLoop.info.id });
+        graph.addEdge(entry, forLoopId + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: forLoopId });
     }
     for (const next of [...body.nexts, ...body.exitPoints]) {
-        graph.addEdge(forLoop.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(forLoopId, next, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const breakPoint of body.breaks) {
-        graph.addEdge(forLoop.info.id + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(forLoopId + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
     const isNotEndless = body.exitPoints.length > 0 || body.breaks.length > 0;
     if (isNotEndless) {
         graph.addVertex({
-            id: forLoop.info.id + '-exit',
+            id: forLoopId + '-exit',
             type: control_flow_graph_1.CfgVertexType.EndMarker,
-            root: forLoop.info.id
+            root: forLoopId
         });
-        graph.addEdge(forLoop.info.id + '-exit', forLoop.info.id + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoop.info.id });
+        graph.addEdge(forLoopId + '-exit', forLoopId + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoopId });
     }
-    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: isNotEndless ? [forLoop.info.id + '-exit'] : [], entryPoints: [forLoop.info.id] };
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: isNotEndless ? [forLoopId + '-exit'] : [], entryPoints: [forLoopId] };
 }
 function cfgFunctionDefinition(fn, params, body) {
+    const fnId = fn.info.id;
     const graph = new control_flow_graph_1.ControlFlowGraph();
-    const children = [fn.info.id + '-params', fn.info.id + '-exit'];
-    graph.addVertex({ id: fn.info.id + '-params', kind: 'parameters', type: control_flow_graph_1.CfgVertexType.MidMarker, root: fn.info.id }, false);
-    graph.addVertex({ id: fn.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: fn.info.id }, false);
-    graph.addVertex({ id: fn.info.id, children, type: identifyMayStatementType(fn), mid: [fn.info.id + '-params'], end: [fn.info.id + '-exit'] });
+    const children = [fnId + '-params', fnId + '-exit'];
+    graph.addVertex({ id: fnId + '-params', kind: 'parameters', type: control_flow_graph_1.CfgVertexType.MidMarker, root: fnId }, false);
+    graph.addVertex({ id: fnId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: fnId }, false);
+    graph.addVertex({ id: fnId, children, type: identifyMayStatementType(fn), mid: [fnId + '-params'], end: [fnId + '-exit'] });
     graph.mergeWith(body.graph, true);
     children.push(...body.graph.rootIds());
     for (const param of params) {
         graph.mergeWith(param.graph, true);
         children.push(...param.graph.rootIds());
         for (const entry of param.entryPoints) {
-            graph.addEdge(entry, fn.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(entry, fnId, { label: 0 /* CfgEdgeType.Fd */ });
         }
         for (const exit of param.exitPoints) {
-            graph.addEdge(fn.info.id + '-params', exit, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(fnId + '-params', exit, { label: 0 /* CfgEdgeType.Fd */ });
         }
     }
     if (params.length === 0) {
-        graph.addEdge(fn.info.id + '-params', fn.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(fnId + '-params', fnId, { label: 0 /* CfgEdgeType.Fd */ });
     }
     for (const entry of body.entryPoints) {
-        graph.addEdge(entry, fn.info.id + '-params', { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, fnId + '-params', { label: 0 /* CfgEdgeType.Fd */ });
     }
-    // breaks and nexts should be illegal but safe is safe i guess
-    for (const next of [...body.returns, ...body.breaks, ...body.nexts, ...body.exitPoints]) {
-        graph.addEdge(fn.info.id + '-exit', next, { label: 0 /* CfgEdgeType.Fd */ });
+    // breaks and nexts should be illegal but safe is safe, I guess
+    for (const next of body.returns.concat(body.breaks, body.nexts, body.exitPoints)) {
+        graph.addEdge(fnId + '-exit', next, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    return { graph: graph, breaks: [], nexts: [], returns: [], exitPoints: [fn.info.id], entryPoints: [fn.info.id] };
+    return { graph: graph, breaks: [], nexts: [], returns: [], exitPoints: [fnId], entryPoints: [fnId] };
 }
 function cfgFunctionCall(call, name, args, exit = 'exit') {
+    const callId = call.info.id;
     const graph = name.graph;
-    const info = { graph, breaks: [...name.breaks], nexts: [...name.nexts], returns: [...name.returns], exitPoints: [call.info.id + '-' + exit], entryPoints: [call.info.id] };
-    graph.addVertex({ id: call.info.id, type: identifyMayStatementType(call), mid: [call.info.id + '-name'], end: [call.info.id + '-' + exit] });
+    const info = { graph, breaks: [...name.breaks], nexts: [...name.nexts], returns: [...name.returns], exitPoints: [callId + '-' + exit], entryPoints: [callId] };
+    graph.addVertex({ id: callId, type: identifyMayStatementType(call), mid: [callId + '-name'], end: [callId + '-' + exit] });
     for (const entryPoint of name.entryPoints) {
-        graph.addEdge(entryPoint, call.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, callId, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    graph.addVertex({ id: call.info.id + '-name', kind: 'name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: call.info.id });
+    graph.addVertex({ id: callId + '-name', kind: 'name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: callId });
     for (const exitPoint of name.exitPoints) {
-        graph.addEdge(call.info.id + '-name', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(callId + '-name', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
     }
-    graph.addVertex({ id: call.info.id + '-' + exit, type: control_flow_graph_1.CfgVertexType.EndMarker, root: call.info.id });
-    let lastArgExits = [call.info.id + '-name'];
+    graph.addVertex({ id: callId + '-' + exit, type: control_flow_graph_1.CfgVertexType.EndMarker, root: callId });
+    let lastArgExits = [callId + '-name'];
     for (const arg of args) {
         if (arg === r_function_call_1.EmptyArgument) {
             continue;
@@ -264,7 +268,7 @@ function cfgFunctionCall(call, name, args, exit = 'exit') {
         lastArgExits = arg.exitPoints;
     }
     for (const exit of lastArgExits) {
-        graph.addEdge(call.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(callId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
     }
     // should not contain any breaks, nexts, or returns, (except for the body if something like 'break()')
     return info;

package/control-flow/semantic-cfg-guided-visitor.d.ts

@@ -1,5 +1,4 @@
 import type { CfgExpressionVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
-import type { DataflowInformation } from '../dataflow/info';
 import type { DataflowCfgGuidedVisitorConfiguration } from './dfg-cfg-guided-visitor';
 import { DataflowAwareCfgGuidedVisitor } from './dfg-cfg-guided-visitor';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
@@ -10,12 +9,14 @@ import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefini
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
-import type { FunctionArgument } from '../dataflow/graph/graph';
+import type { DataflowGraph, FunctionArgument } from '../dataflow/graph/graph';
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { BuiltInProcessorMapper } from '../dataflow/environments/built-in';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-export interface SemanticCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowInformation = DataflowInformation> extends DataflowCfgGuidedVisitorConfiguration<Cfg, Dfg>, SyntaxCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast> {
+import type { FlowrConfigOptions } from '../config';
+export interface SemanticCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowGraph = DataflowGraph> extends DataflowCfgGuidedVisitorConfiguration<ControlFlow, Dfg>, SyntaxCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast> {
+    readonly flowrConfig: FlowrConfigOptions;
 }
 /**
  * This visitor extends on the {@link DataflowAwareCfgGuidedVisitor} by dispatching visitors for separate function calls as well,
@@ -40,7 +41,7 @@ export interface SemanticCfgGuidedVisitorConfiguration<OtherInfo = NoInfo, Cfg e
  *
  * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
  */
-export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowInformation = DataflowInformation, Config extends SemanticCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast, Dfg> = SemanticCfgGuidedVisitorConfiguration<OtherInfo, Cfg, Ast, Dfg>> extends DataflowAwareCfgGuidedVisitor<Cfg, Dfg, Config> {
+export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, ControlFlow extends ControlFlowInformation = ControlFlowInformation, Ast extends NormalizedAst<OtherInfo> = NormalizedAst<OtherInfo>, Dfg extends DataflowGraph = DataflowGraph, Config extends SemanticCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg> = SemanticCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dfg>> extends DataflowAwareCfgGuidedVisitor<ControlFlow, Dfg, Config> {
     /**
      * A helper function to get the normalized AST node for the given id or fail if it does not exist.
      */
@@ -117,12 +118,21 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      * @protected
      */
     protected onDispatchFunctionCallOrigin(call: DataflowGraphVertexFunctionCall, origin: keyof typeof BuiltInProcessorMapper | string): void;
+    /**
+     * This event is called for the root program node, i.e., the program that is being analyzed.
+     *
+     * @protected
+     */
     protected onProgram(_data: RExpressionList<OtherInfo>): void;
     /**
      * A helper function to request the {@link getOriginInDfg|origins} of the given node.
      */
     protected getOrigins(id: NodeId): Origin[] | undefined;
-    /** Called for every occurrence of a `NULL` in the program. */
+    /**
+     * Called for every occurrence of a `NULL` in the program.
+     *
+     * For other symbols that are not referenced as a variable, see {@link SemanticCfgGuidedVisitor#onSymbolConstant|`onSymbolConstant`}.
+     */
     protected onNullConstant(_data: {
         vertex: DataflowGraphVertexValue;
         node: RSymbol<OtherInfo & ParentInformation, 'NULL'>;
@@ -154,6 +164,18 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
         vertex: DataflowGraphVertexValue;
         node: RLogical;
     }): void;
+    /**
+     * Called for every constant symbol value in the program.
+     *
+     * For example, `foo` in `library(foo)` or `a` in `l$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, `NULL` is handled in {@link SemanticCfgGuidedVisitor#onNullConstant|`onNullConstant`} and not here.
+     */
+    protected onSymbolConstant(_data: {
+        vertex: DataflowGraphVertexValue;
+        node: RSymbol;
+    }): void;
     /**
      * Called for every variable that is read within the program.
      * You can use {@link getOrigins} to get the origins of the variable.
@@ -180,6 +202,7 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onFunctionDefinition(_data: {
         vertex: DataflowGraphVertexFunctionDefinition;
+        parameters?: readonly NodeId[];
     }): void;
     /**
      * This event triggers for every anonymous call within the program.
@@ -211,7 +234,7 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      *
      * 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 {@link SemanticCfgGuidedVisitor#onUnnamedCall|`onUnnamedCall`} event.
-     * The main reason for this separation is part of flowR's handling of these functions, as anonmyous calls cannot be resolved using the active environment.
+     * 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.
      *
      * @protected
      */
@@ -282,9 +305,9 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onIfThenElseCall(_data: {
         call: DataflowGraphVertexFunctionCall;
-        condition: FunctionArgument;
-        then: FunctionArgument;
-        else: FunctionArgument | undefined;
+        condition: NodeId | undefined;
+        then: NodeId | undefined;
+        else: NodeId | undefined;
     }): void;
     /**
      * This event triggers for every call to the `get` function, which is used to access variables in the global environment.
@@ -346,6 +369,8 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onSpecialBinaryOpCall(_data: {
         call: DataflowGraphVertexFunctionCall;
+        lhs?: FunctionArgument;
+        rhs?: FunctionArgument;
     }): void;
     /**
      * This event triggers for every call to R's pipe operator, i.e., for every call to `|>`.
@@ -354,6 +379,8 @@ export declare class SemanticCfgGuidedVisitor<OtherInfo = NoInfo, Cfg extends Co
      */
     protected onPipeCall(_data: {
         call: DataflowGraphVertexFunctionCall;
+        lhs?: FunctionArgument;
+        rhs?: FunctionArgument;
     }): void;
     /**
      * This event triggers for every call to the `quote` function, which is used to quote expressions.