@eagleoutice/flowr 2.2.14 → 2.2.15

package/README.md

@@ -51,7 +51,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.2.13, R v4.4.3 (r-shell engine)
+    flowR repl using flowR v2.2.14, R v4.4.3 (r-shell engine)
     R> :slicer test/testfiles/example.R --criterion "11@sum"
     ```
     
@@ -98,7 +98,7 @@ It offers a wide variety of features, for example:
         
 
 * 🚀 **fast data- and control-flow graphs**\
-  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">139.5 ms</span></i> (as of May 27, 2025), 
+  Within just <i><span title="This measurement is automatically fetched from the latest benchmark!">133.8 ms</span></i> (as of May 31, 2025), 
   _flowR_ can analyze the data- and control-flow of the average real-world R script. See the [benchmarks](https://flowr-analysis.github.io/flowr/wiki/stats/benchmark) for more information,
   and consult the [wiki pages](https://github.com/flowr-analysis/flowr/wiki/Dataflow-Graph) for more details on the dataflow graph.
 
@@ -134,7 +134,7 @@ It offers a wide variety of features, for example:
     
     ```shell
     $ docker run -it --rm eagleoutice/flowr # or npm run flowr 
-    flowR repl using flowR v2.2.13, R v4.4.3 (r-shell engine)
+    flowR repl using flowR v2.2.14, R v4.4.3 (r-shell engine)
     R> :dataflow* test/testfiles/example.R
     ```
     
@@ -435,7 +435,7 @@ It offers a wide variety of features, for example:
     ```
     
     	
-    (The analysis required _22.0 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
+    (The analysis required _22.8 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
     
     
     

package/cli/repl/commands/repl-commands.js

@@ -53,7 +53,7 @@ exports.helpCommand = {
     fn: output => {
         initCommandMapping();
         output.stdout(`
-If enabled ('--r-session-access'), you can just enter R expressions which get evaluated right away:
+If enabled ('--r-session-access' and if using the 'r-shell' engine), you can just enter R expressions which get evaluated right away:
 ${prompt_1.rawPrompt} ${(0, ansi_1.bold)('1 + 1', output.formatter)}
 ${(0, ansi_1.italic)('[1] 2', output.formatter)}
 

package/cli/repl/commands/repl-execute.js

@@ -6,7 +6,8 @@ const ansi_1 = require("../../../util/text/ansi");
 const shell_1 = require("../../../r-bridge/shell");
 async function tryExecuteRShellCommand(output, parser, statement, allowRSessionAccess) {
     if (!allowRSessionAccess) {
-        output.stderr(`${output.formatter.format('You are not allowed to execute arbitrary R code.', { style: 1 /* FontStyles.Bold */, color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground })}\nIf you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })} flag. Please be careful of the security implications of this action.`);
+        output.stderr(`${output.formatter.format('You are not allowed to execute arbitrary R code.', { style: 1 /* FontStyles.Bold */, color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground })} 
+If you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })} flag${parser.name !== 'r-shell' ? '. Additionally, please enable the r-shell engine, e.g., with ' + output.formatter.format('--default-engine r-shell', { style: 1 /* FontStyles.Bold */ }) : ''}. Please be careful of the security implications of this action.`);
     }
     else if (parser instanceof shell_1.RShell) {
         await executeRShellCommand(output, parser, statement);

package/config.js

@@ -67,7 +67,7 @@ exports.defaultConfigOptions = {
         }
     },
     engines: [],
-    defaultEngine: 'r-shell',
+    defaultEngine: 'tree-sitter',
     solver: {
         variables: VariableResolve.Alias,
         evalStrings: true,

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

@@ -1,7 +1,7 @@
 import type { CfgBasicBlockVertex, CfgEndMarkerVertex, CfgExpressionVertex, CfgMidMarkerVertex, CfgSimpleVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-export interface BasicCfgGuidedVisitorConfiguration<Cfg extends ControlFlowInformation = ControlFlowInformation> {
-    readonly controlFlow: Cfg;
+export interface BasicCfgGuidedVisitorConfiguration<ControlFlow extends ControlFlowInformation = ControlFlowInformation> {
+    readonly controlFlow: ControlFlow;
     readonly defaultVisitingOrder: 'forward' | 'backward';
 }
 /**
@@ -11,7 +11,7 @@ export interface BasicCfgGuidedVisitorConfiguration<Cfg extends ControlFlowInfor
  *
  * Use {@link BasicCfgGuidedVisitor#start} to start the traversal.
  */
-export declare class BasicCfgGuidedVisitor<Cfg extends ControlFlowInformation = ControlFlowInformation, Config extends BasicCfgGuidedVisitorConfiguration<Cfg> = BasicCfgGuidedVisitorConfiguration<Cfg>> {
+export declare class BasicCfgGuidedVisitor<ControlFlow extends ControlFlowInformation = ControlFlowInformation, Config extends BasicCfgGuidedVisitorConfiguration<ControlFlow> = BasicCfgGuidedVisitorConfiguration<ControlFlow>> {
     protected readonly config: Config;
     protected readonly visited: Map<NodeId, number>;
     constructor(config: Config);

package/control-flow/cfg-dead-code.d.ts

@@ -0,0 +1,4 @@
+import type { ControlFlowInformation } from './control-flow-graph';
+import type { CfgPassInfo } from './cfg-simplification';
+/** Breaks unsatisfiable control dependencies */
+export declare function cfgAnalyzeDeadCode(cfg: ControlFlowInformation, info: CfgPassInfo): ControlFlowInformation;

package/control-flow/cfg-dead-code.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cfgAnalyzeDeadCode = cfgAnalyzeDeadCode;
+const logic_1 = require("../util/logic");
+const semantic_cfg_guided_visitor_1 = require("./semantic-cfg-guided-visitor");
+const alias_tracking_1 = require("../dataflow/eval/resolve/alias-tracking");
+const log_1 = require("../util/log");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const general_1 = require("../dataflow/eval/values/general");
+const r_value_1 = require("../dataflow/eval/values/r-value");
+class CfgConditionalDeadCodeRemoval extends semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor {
+    cachedConditions = new Map();
+    getValue(id) {
+        const has = this.cachedConditions.get(id);
+        if (has) {
+            return has;
+        }
+        this.visitNode(id);
+        return this.cachedConditions.get(id) ?? logic_1.Ternary.Maybe;
+    }
+    unableToCalculateValue(id) {
+        this.cachedConditions.set(id, logic_1.Ternary.Maybe);
+    }
+    storeDefiniteValue(id, value) {
+        this.cachedConditions.set(id, value ? logic_1.Ternary.Always : logic_1.Ternary.Never);
+    }
+    startVisitor() {
+        for (const [from, targets] of this.config.controlFlow.graph.edges()) {
+            for (const [target, edge] of targets) {
+                if (edge.label === 1 /* CfgEdgeType.Cd */) {
+                    const og = this.getValue(edge.caused);
+                    if (og === logic_1.Ternary.Always && edge.when === 'FALSE') {
+                        this.config.controlFlow.graph.removeEdge(from, target);
+                    }
+                    else if (og === logic_1.Ternary.Never && edge.when === 'TRUE') {
+                        this.config.controlFlow.graph.removeEdge(from, target);
+                    }
+                }
+            }
+        }
+    }
+    handleValuesFor(id, valueId) {
+        const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(valueId, { graph: this.config.dfg, full: true, idMap: this.config.normalizedAst.idMap }));
+        if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
+            this.unableToCalculateValue(id);
+            return;
+        }
+        /* we should translate this to truthy later */
+        this.storeDefiniteValue(id, Boolean(values.elements[0].value));
+    }
+    handleWithCondition(data) {
+        const id = data.call.id;
+        if (data.condition === undefined || data.condition === r_function_call_1.EmptyArgument) {
+            this.unableToCalculateValue(id);
+            return;
+        }
+        this.handleValuesFor(id, typeof data.condition === 'object' ? data.condition.nodeId : data.condition);
+    }
+    onIfThenElseCall(data) {
+        this.handleWithCondition(data);
+    }
+    onWhileLoopCall(data) {
+        this.handleWithCondition(data);
+    }
+}
+/** Breaks unsatisfiable control dependencies */
+function cfgAnalyzeDeadCode(cfg, info) {
+    if (!info.ast || !info.dfg) {
+        log_1.log.warn('cfgAnalyzeDeadCode called without ast or dfg, skipping dead code analysis');
+        return cfg;
+    }
+    const visitor = new CfgConditionalDeadCodeRemoval({
+        controlFlow: cfg,
+        normalizedAst: info.ast,
+        dfg: info.dfg,
+        defaultVisitingOrder: 'forward'
+    });
+    visitor.start();
+    return cfg;
+}
+//# sourceMappingURL=cfg-dead-code.js.map

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

@@ -1,7 +1,15 @@
 import type { ControlFlowInformation } from './control-flow-graph';
-export type CfgSimplificationPass = (cfg: ControlFlowInformation) => ControlFlowInformation;
-declare const CfgSimplificationPasses: {
+import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowGraph } from '../dataflow/graph/graph';
+import { cfgAnalyzeDeadCode } from './cfg-dead-code';
+export interface CfgPassInfo {
+    ast?: NormalizedAst;
+    dfg?: DataflowGraph;
+}
+export type CfgSimplificationPass = (cfg: ControlFlowInformation, info: CfgPassInfo) => ControlFlowInformation;
+export declare const CfgSimplificationPasses: {
     readonly 'unique-cf-sets': typeof uniqueControlFlowSets;
+    readonly 'analyze-dead-code': typeof cfgAnalyzeDeadCode;
     readonly 'remove-dead-code': typeof cfgRemoveDeadCode;
     readonly 'to-basic-blocks': typeof toBasicBlocks;
 };
@@ -11,8 +19,11 @@ export declare const DefaultCfgSimplificationOrder: ["unique-cf-sets"];
  * 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.
  */
-export declare function simplifyControlFlowInformation(cfg: ControlFlowInformation, passes?: readonly CfgSimplificationPassName[]): ControlFlowInformation;
-declare function uniqueControlFlowSets(cfg: ControlFlowInformation): ControlFlowInformation;
-declare function cfgRemoveDeadCode(cfg: ControlFlowInformation): ControlFlowInformation;
-declare function toBasicBlocks(cfg: ControlFlowInformation): ControlFlowInformation;
+export declare function simplifyControlFlowInformation(cfg: ControlFlowInformation, info: CfgPassInfo, passes?: readonly CfgSimplificationPassName[]): ControlFlowInformation;
+/**
+ * removes dead vertices and edges from the control flow graph.
+ */
+declare function cfgRemoveDeadCode(cfg: ControlFlowInformation, _info?: CfgPassInfo): ControlFlowInformation;
+declare function uniqueControlFlowSets(cfg: ControlFlowInformation, _info?: CfgPassInfo): ControlFlowInformation;
+declare function toBasicBlocks(cfg: ControlFlowInformation, _info?: CfgPassInfo): ControlFlowInformation;
 export {};

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

@@ -70,7 +70,7 @@ export declare function equalVertex(a: CfgSimpleVertex, b: CfgSimpleVertex): boo
 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 +166,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

@@ -55,6 +55,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,18 +1,18 @@
 import type { CfgExpressionVertex, CfgStatementVertex, 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;
 }
 /**
  * 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
      */

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

@@ -14,7 +14,7 @@ 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);

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

@@ -14,7 +14,7 @@ import type { CfgSimplificationPassName } from './cfg-simplification';
  *
  * @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>, graph?: DataflowGraph, simplifications?: readonly CfgSimplificationPassName[]): ControlFlowInformation;
 /**
  * Simplified version of {@link extractCfg} that is much quicker, but much simpler!
  */

package/control-flow/extract-cfg.js

@@ -63,7 +63,7 @@ function dataflowCfgFolds(dataflowGraph) {
  * @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);
+    return (0, cfg_simplification_1.simplifyControlFlowInformation)((0, fold_1.foldAst)(ast.ast, graph ? dataflowCfgFolds(graph) : cfgFolds), { ast, dfg: graph }, simplifications);
 }
 /**
  * Simplified version of {@link extractCfg} that is much quicker, but much simpler!
@@ -72,10 +72,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 +89,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 +143,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 +267,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;