@eagleoutice/flowr 2.9.7 → 2.9.9

package/control-flow/extract-cfg.js

@@ -7,7 +7,6 @@ exports.getCallsInCfg = getCallsInCfg;
 exports.cfg2quads = cfg2quads;
 const quads_1 = require("../util/quads");
 const fold_1 = require("../r-bridge/lang-4.x/ast/model/processing/fold");
-const convert_values_1 = require("../r-bridge/lang-4.x/convert-values");
 const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const linker_1 = require("../dataflow/internal/linker");
 const vertex_1 = require("../dataflow/graph/vertex");
@@ -102,35 +101,57 @@ function cfgFoldProject(proj, folds) {
     else if (proj.files.length === 1) {
         return (0, fold_1.foldAst)(proj.files[0].root, folds);
     }
-    const perProject = proj.files.map(file => (0, fold_1.foldAst)(file.root, folds));
-    const finalGraph = perProject[0].graph;
-    for (let i = 1; i < perProject.length; i++) {
-        finalGraph.mergeWith(perProject[i].graph);
-        for (const exitPoint of perProject[i - 1].exitPoints) {
-            for (const entryPoint of perProject[i].entryPoints) {
-                finalGraph.addEdge(entryPoint, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+    /* for many files, it is too expensive to keep all asts at once, hence we create and merge them incrementally */
+    let exitPoints;
+    let finalGraph;
+    let firstEntryPoints;
+    let breaks;
+    let nexts;
+    let returns;
+    {
+        const firstInfo = (0, fold_1.foldAst)(proj.files[0].root, folds);
+        exitPoints = firstInfo.exitPoints;
+        finalGraph = firstInfo.graph;
+        firstEntryPoints = firstInfo.entryPoints;
+        breaks = firstInfo.breaks;
+        nexts = firstInfo.nexts;
+        returns = firstInfo.returns;
+    }
+    for (let i = 1; i < proj.files.length; i++) {
+        const nextInfo = (0, fold_1.foldAst)(proj.files[i].root, folds);
+        finalGraph.mergeWith(nextInfo.graph);
+        for (const exitPoint of exitPoints) {
+            for (const entryPoint of nextInfo.entryPoints) {
+                finalGraph.addEdge(entryPoint, exitPoint, control_flow_graph_1.CfgEdge.makeFd());
             }
         }
+        exitPoints = nextInfo.exitPoints;
+        breaks.push(...nextInfo.breaks);
+        nexts.push(...nextInfo.nexts);
+        returns.push(...nextInfo.returns);
     }
     return {
-        breaks: perProject.flatMap(e => e.breaks),
-        nexts: perProject.flatMap(e => e.nexts),
-        returns: perProject.flatMap(e => e.returns),
-        exitPoints: perProject.at(-1).exitPoints,
-        entryPoints: perProject[0].entryPoints,
+        breaks,
+        nexts,
+        returns,
+        exitPoints,
+        entryPoints: firstEntryPoints,
         graph: finalGraph
     };
 }
 function cfgLeaf(type) {
-    return ({ info: { id } }) => {
-        return { graph: new control_flow_graph_1.ControlFlowGraph().addVertex({ id, type }), breaks: [], nexts: [], returns: [], exitPoints: [id], entryPoints: [id] };
+    return type === control_flow_graph_1.CfgVertexType.Expression ? ({ info: { id } }) => {
+        return { graph: new control_flow_graph_1.ControlFlowGraph().addVertex(control_flow_graph_1.CfgVertex.makeExpression(id)), breaks: [], nexts: [], returns: [], exitPoints: [id], entryPoints: [id] };
+    } : ({ info: { id } }) => {
+        return { graph: new control_flow_graph_1.ControlFlowGraph().addVertex(control_flow_graph_1.CfgVertex.makeStatement(id)), breaks: [], nexts: [], returns: [], exitPoints: [id], entryPoints: [id] };
     };
 }
+const cfgLeafStatement = cfgLeaf(control_flow_graph_1.CfgVertexType.Statement);
 function cfgBreak(leaf) {
-    return { ...cfgLeaf(control_flow_graph_1.CfgVertexType.Statement)(leaf), breaks: [leaf.info.id], exitPoints: [] };
+    return { ...cfgLeafStatement(leaf), breaks: [leaf.info.id], exitPoints: [] };
 }
 function cfgNext(leaf) {
-    return { ...cfgLeaf(control_flow_graph_1.CfgVertexType.Statement)(leaf), nexts: [leaf.info.id], exitPoints: [] };
+    return { ...cfgLeafStatement(leaf), nexts: [leaf.info.id], exitPoints: [] };
 }
 function cfgIgnore(_leaf) {
     return { graph: new control_flow_graph_1.ControlFlowGraph(), breaks: [], nexts: [], returns: [], exitPoints: [], entryPoints: [] };
@@ -141,32 +162,34 @@ function identifyMayStatementType(node) {
 function cfgIfThenElse(ifNode, condition, then, otherwise) {
     const ifId = ifNode.info.id;
     const graph = new control_flow_graph_1.ControlFlowGraph();
-    graph.addVertex({ id: ifId, type: identifyMayStatementType(ifNode), mid: condition.exitPoints, end: [ifId + '-exit'] });
-    graph.addVertex({ id: ifId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: ifId });
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExprOrStm(ifId, identifyMayStatementType(ifNode), { mid: condition.exitPoints, end: [control_flow_graph_1.CfgVertex.toExitId(ifId)] }));
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(ifId));
     graph.mergeWith(condition.graph);
     graph.mergeWith(then.graph);
     if (otherwise) {
         graph.mergeWith(otherwise.graph);
     }
+    const cdTrue = control_flow_graph_1.CfgEdge.makeCdTrue(ifId);
+    const cdFalse = control_flow_graph_1.CfgEdge.makeCdFalse(ifId);
     for (const e of condition.exitPoints) {
         for (const entryPoint of then.entryPoints) {
-            graph.addEdge(entryPoint, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: ifId });
+            graph.addEdge(entryPoint, e, cdTrue);
         }
         for (const entryPoint of otherwise?.entryPoints ?? []) {
-            graph.addEdge(entryPoint, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
+            graph.addEdge(entryPoint, e, cdFalse);
         }
     }
     for (const entryPoint of condition.entryPoints) {
-        graph.addEdge(entryPoint, ifId, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, ifId, control_flow_graph_1.CfgEdge.makeFd());
     }
     for (const exits of [then.exitPoints, otherwise?.exitPoints ?? []]) {
         for (const exit of exits) {
-            graph.addEdge(ifId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(ifId), exit, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     if (!otherwise) {
         for (const e of condition.exitPoints) {
-            graph.addEdge(ifId + '-exit', e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: ifId });
+            graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(ifId), e, control_flow_graph_1.CfgEdge.makeCdFalse(ifId));
         }
     }
     return {
@@ -174,107 +197,100 @@ function cfgIfThenElse(ifNode, condition, then, otherwise) {
         breaks: then.breaks.concat(otherwise?.breaks ?? []),
         nexts: then.nexts.concat(otherwise?.nexts ?? []),
         returns: then.returns.concat(otherwise?.returns ?? []),
-        exitPoints: [ifId + '-exit'],
+        exitPoints: [control_flow_graph_1.CfgVertex.toExitId(ifId)],
         entryPoints: [ifId]
     };
 }
 function cfgRepeat(repeat, body) {
     const graph = body.graph;
-    graph.addVertex({ id: repeat.info.id, type: identifyMayStatementType(repeat), end: [repeat.info.id + '-exit'] });
-    graph.addVertex({ id: repeat.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: repeat.info.id });
+    const rid = repeat.info.id;
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExprOrStm(rid, identifyMayStatementType(repeat), { end: [control_flow_graph_1.CfgVertex.toExitId(rid)] }));
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(rid));
     for (const entryPoint of body.entryPoints) {
-        graph.addEdge(entryPoint, repeat.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, rid, control_flow_graph_1.CfgEdge.makeFd());
     }
     // loops automatically
     for (const nexts of [body.nexts, body.exitPoints]) {
         for (const next of nexts) {
-            graph.addEdge(repeat.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(rid, next, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     for (const breakPoint of body.breaks) {
-        graph.addEdge(repeat.info.id + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(rid), breakPoint, control_flow_graph_1.CfgEdge.makeFd());
     }
-    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [repeat.info.id + '-exit'], entryPoints: [repeat.info.id] };
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [control_flow_graph_1.CfgVertex.toExitId(rid)], entryPoints: [rid] };
 }
 function cfgWhile(whileLoop, condition, body) {
     const whileId = whileLoop.info.id;
     const graph = condition.graph;
-    graph.addVertex({ id: whileId, type: identifyMayStatementType(whileLoop), mid: condition.exitPoints, end: [whileId + '-exit'] });
-    graph.addVertex({ id: whileId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: whileId });
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExprOrStm(whileId, identifyMayStatementType(whileLoop), { mid: condition.exitPoints, end: [control_flow_graph_1.CfgVertex.toExitId(whileId)] }));
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(whileId));
     graph.mergeWith(body.graph);
     for (const entry of condition.entryPoints) {
-        graph.addEdge(entry, whileId, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, whileId, control_flow_graph_1.CfgEdge.makeFd());
     }
     for (const e of condition.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: whileId });
+            graph.addEdge(entry, e, control_flow_graph_1.CfgEdge.makeCdTrue(whileId));
         }
     }
     for (const nexts of [body.nexts, body.exitPoints]) {
         for (const next of nexts) {
-            graph.addEdge(whileId, next, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(whileId, next, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     for (const breakPoint of body.breaks) {
-        graph.addEdge(whileId + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(whileId), breakPoint, control_flow_graph_1.CfgEdge.makeFd());
     }
     // while can break on the condition as well
     for (const e of condition.exitPoints) {
-        graph.addEdge(whileId + '-exit', e, {
-            label: 1 /* CfgEdgeType.Cd */,
-            when: convert_values_1.RFalse,
-            caused: whileId
-        });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(whileId), e, control_flow_graph_1.CfgEdge.makeCdFalse(whileId));
     }
-    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [whileId + '-exit'], entryPoints: [whileId] };
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [control_flow_graph_1.CfgVertex.toExitId(whileId)], entryPoints: [whileId] };
 }
 function cfgFor(forLoop, variable, vector, body) {
     const forLoopId = forLoop.info.id;
     const graph = variable.graph;
-    graph.addVertex({ id: forLoopId, type: identifyMayStatementType(forLoop), end: [forLoopId + '-exit'], mid: variable.exitPoints });
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExprOrStm(forLoopId, identifyMayStatementType(forLoop), { mid: variable.exitPoints, end: [control_flow_graph_1.CfgVertex.toExitId(forLoopId)] }));
     graph.mergeWith(vector.graph);
     graph.mergeWith(body.graph);
     for (const entry of vector.entryPoints) {
-        graph.addEdge(entry, forLoopId, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, forLoopId, control_flow_graph_1.CfgEdge.makeFd());
     }
     for (const exit of vector.exitPoints) {
         for (const entry of variable.entryPoints) {
-            graph.addEdge(entry, exit, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(entry, exit, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     for (const e of variable.exitPoints) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RTrue, caused: forLoopId });
+            graph.addEdge(entry, e, control_flow_graph_1.CfgEdge.makeCdTrue(forLoopId));
         }
     }
     for (const points of [body.nexts, body.exitPoints]) {
         for (const next of points) {
-            graph.addEdge(forLoopId, next, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(forLoopId, next, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     for (const breakPoint of body.breaks) {
-        graph.addEdge(forLoopId + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(forLoopId), breakPoint, control_flow_graph_1.CfgEdge.makeFd());
     }
     const isNotEndless = body.exitPoints.length > 0 || body.breaks.length > 0;
     if (isNotEndless) {
-        graph.addVertex({
-            id: forLoopId + '-exit',
-            type: control_flow_graph_1.CfgVertexType.EndMarker,
-            root: forLoopId
-        });
+        graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(forLoopId));
         for (const e of variable.exitPoints) {
-            graph.addEdge(forLoopId + '-exit', e, { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoopId });
+            graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(forLoopId), e, control_flow_graph_1.CfgEdge.makeCdFalse(forLoopId));
         }
     }
-    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: isNotEndless ? [forLoopId + '-exit'] : [], entryPoints: [forLoopId] };
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: isNotEndless ? [control_flow_graph_1.CfgVertex.toExitId(forLoopId)] : [], entryPoints: [forLoopId] };
 }
 function cfgFunctionDefinition(fn, params, body) {
     const fnId = fn.info.id;
     const graph = new control_flow_graph_1.ControlFlowGraph();
     let paramExits = params.flatMap(e => e.exitPoints);
-    const children = [...paramExits, fnId + '-exit'];
-    graph.addVertex({ id: fnId + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: fnId }, false);
-    graph.addVertex({ id: fnId, children, type: identifyMayStatementType(fn), mid: paramExits, end: [fnId + '-exit'] });
+    const children = [...paramExits, control_flow_graph_1.CfgVertex.toExitId(fnId)];
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(fnId), false);
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExprOrStm(fnId, identifyMayStatementType(fn), { children, mid: paramExits, end: [control_flow_graph_1.CfgVertex.toExitId(fnId)] }));
     graph.mergeWith(body.graph, true);
     for (const r of body.graph.rootIds()) {
         children.push(r);
@@ -285,7 +301,7 @@ function cfgFunctionDefinition(fn, params, body) {
             children.push(r);
         }
         for (const entry of param.entryPoints) {
-            graph.addEdge(entry, fnId, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(entry, fnId, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     if (paramExits.length === 0) {
@@ -293,16 +309,16 @@ function cfgFunctionDefinition(fn, params, body) {
     }
     for (const e of paramExits) {
         for (const entry of body.entryPoints) {
-            graph.addEdge(entry, e, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(entry, e, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     // 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 */ });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(fnId), next, control_flow_graph_1.CfgEdge.makeFd());
     }
     return { graph: graph, breaks: [], nexts: [], returns: [], exitPoints: [fnId], entryPoints: [fnId] };
 }
-function cfgFunctionCall(call, name, args, exit = 'exit') {
+function cfgFunctionCall(call, name, args) {
     if (call.named && call.functionName.content === 'ifelse') {
         // special built-in handling for ifelse as it is an expression that does not short-circuit
         return cfgIfThenElse(call, args[0] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[0], args[1] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[1], args[2] === r_function_call_1.EmptyArgument ? (0, control_flow_graph_1.emptyControlFlowInformation)() : args[2]);
@@ -314,14 +330,14 @@ function cfgFunctionCall(call, name, args, exit = 'exit') {
         breaks: Array.from(name.breaks),
         nexts: Array.from(name.nexts),
         returns: Array.from(name.returns),
-        exitPoints: [callId + '-' + exit],
+        exitPoints: [control_flow_graph_1.CfgVertex.toExitId(callId)],
         entryPoints: [callId]
     };
-    graph.addVertex({ id: callId, type: identifyMayStatementType(call), mid: name.exitPoints, end: [callId + '-' + exit] });
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExprOrStm(callId, identifyMayStatementType(call), { mid: name.exitPoints, end: [control_flow_graph_1.CfgVertex.toExitId(callId)] }));
     for (const entryPoint of name.entryPoints) {
-        graph.addEdge(entryPoint, callId, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, callId, control_flow_graph_1.CfgEdge.makeFd());
     }
-    graph.addVertex({ id: callId + '-' + exit, type: control_flow_graph_1.CfgVertexType.EndMarker, root: callId });
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(callId));
     let lastArgExits = name.exitPoints;
     for (const arg of args) {
         if (arg === r_function_call_1.EmptyArgument) {
@@ -333,22 +349,22 @@ function cfgFunctionCall(call, name, args, exit = 'exit') {
         info.returns = info.returns.concat(arg.returns);
         for (const entry of arg.entryPoints) {
             for (const exit of lastArgExits) {
-                graph.addEdge(entry, exit, { label: 0 /* CfgEdgeType.Fd */ });
+                graph.addEdge(entry, exit, control_flow_graph_1.CfgEdge.makeFd());
             }
         }
         lastArgExits = arg.exitPoints;
     }
     for (const exit of lastArgExits) {
-        graph.addEdge(callId + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(callId), exit, control_flow_graph_1.CfgEdge.makeFd());
     }
     if (call.named && call.functionName.content === 'return') {
-        info.returns.push(callId + '-exit');
+        info.returns.push(control_flow_graph_1.CfgVertex.toExitId(callId));
         info.exitPoints.length = 0;
     }
     // should not contain any breaks, nexts, or returns, (except for the body if something like 'break()')
     return info;
 }
-exports.ResolvedCallSuffix = '-resolved-call-exit';
+exports.ResolvedCallSuffix = control_flow_graph_1.CfgVertex.toExitId('-resolved-call');
 const OriginToFoldTypeMap = {
     [built_in_1.BuiltInProcName.IfThenElse]: (folds, call, args) => {
         // arguments are in order!
@@ -374,20 +390,21 @@ function cfgFunctionCallWithDataflow(graph, folds) {
         for (const target of targets) {
             // we have to filter out non-func-call targets as the call targets contains names and call ids
             if ((0, vertex_1.isFunctionDefinitionVertex)(graph.getVertex(target))) {
-                callVertex.callTargets ??= new Set();
-                callVertex.callTargets.add(target);
-                exits.push(target + '-exit');
+                const ct = control_flow_graph_1.CfgVertex.getCallTargets(callVertex);
+                if (!ct) {
+                    control_flow_graph_1.CfgVertex.setCallTargets(callVertex, new Set([target]));
+                }
+                else {
+                    ct.add(target);
+                }
+                exits.push(control_flow_graph_1.CfgVertex.toExitId(target));
             }
         }
         if (exits.length > 0) {
-            baseCfg.graph.addVertex({
-                id: call.info.id + exports.ResolvedCallSuffix,
-                type: control_flow_graph_1.CfgVertexType.EndMarker,
-                root: call.info.id
-            });
+            baseCfg.graph.addVertex(control_flow_graph_1.CfgVertex.makeMarker(call.info.id + exports.ResolvedCallSuffix, call.info.id));
             for (const col of [baseCfg.exitPoints, exits]) {
                 for (const exit of col) {
-                    baseCfg.graph.addEdge(call.info.id + exports.ResolvedCallSuffix, exit, { label: 0 /* CfgEdgeType.Fd */ });
+                    baseCfg.graph.addEdge(call.info.id + exports.ResolvedCallSuffix, exit, control_flow_graph_1.CfgEdge.makeFd());
                 }
             }
             return {
@@ -402,16 +419,17 @@ function cfgFunctionCallWithDataflow(graph, folds) {
 }
 function cfgArgumentOrParameter(node, name, value) {
     const graph = new control_flow_graph_1.ControlFlowGraph();
-    const info = { graph, breaks: [], nexts: [], returns: [], exitPoints: [node.info.id + '-exit'], entryPoints: [node.info.id] };
-    let currentExitPoints = name?.exitPoints ?? [node.info.id];
-    graph.addVertex({ id: node.info.id, type: control_flow_graph_1.CfgVertexType.Expression, mid: currentExitPoints, end: [node.info.id + '-exit'] });
+    const nodeId = node.info.id;
+    const info = { graph, breaks: [], nexts: [], returns: [], exitPoints: [control_flow_graph_1.CfgVertex.toExitId(nodeId)], entryPoints: [nodeId] };
+    let currentExitPoints = name?.exitPoints ?? [nodeId];
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExpressionWithEnd(nodeId, { mid: currentExitPoints }));
     if (name) {
         graph.mergeWith(name.graph);
         info.breaks = info.breaks.concat(name.breaks);
         info.nexts = info.nexts.concat(name.nexts);
         info.returns = info.returns.concat(name.returns);
         for (const entry of name.entryPoints) {
-            graph.addEdge(entry, node.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+            graph.addEdge(entry, nodeId, control_flow_graph_1.CfgEdge.makeFd());
         }
     }
     if (value) {
@@ -421,42 +439,46 @@ function cfgArgumentOrParameter(node, name, value) {
         info.returns = info.returns.concat(value.returns);
         for (const exitPoint of currentExitPoints) {
             for (const entry of value.entryPoints) {
-                graph.addEdge(entry, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+                graph.addEdge(entry, exitPoint, control_flow_graph_1.CfgEdge.makeFd());
             }
         }
         currentExitPoints = value.exitPoints;
     }
-    graph.addVertex({ id: node.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: node.info.id });
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(nodeId));
     for (const exit of currentExitPoints) {
-        graph.addEdge(node.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(nodeId), exit, control_flow_graph_1.CfgEdge.makeFd());
     }
     return info;
 }
 function cfgBinaryOp(binOp, lhs, rhs) {
-    const graph = new control_flow_graph_1.ControlFlowGraph().mergeWith(lhs.graph).mergeWith(rhs.graph);
-    const result = { graph, breaks: lhs.breaks.concat(rhs.breaks), nexts: lhs.nexts.concat(rhs.nexts), returns: lhs.returns.concat(rhs.returns), entryPoints: [binOp.info.id], exitPoints: [binOp.info.id + '-exit'] };
-    graph.addVertex({ id: binOp.info.id, type: binOp.flavor === 'assignment' ? control_flow_graph_1.CfgVertexType.Statement : control_flow_graph_1.CfgVertexType.Expression, end: [binOp.info.id + '-exit'] });
-    graph.addVertex({ id: binOp.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: binOp.info.id });
+    const graph = lhs.graph.mergeWith(rhs.graph);
+    const binId = binOp.info.id;
+    const binExit = control_flow_graph_1.CfgVertex.toExitId(binId);
+    const result = { graph, breaks: lhs.breaks.concat(rhs.breaks), nexts: lhs.nexts.concat(rhs.nexts), returns: lhs.returns.concat(rhs.returns), entryPoints: [binId], exitPoints: [binExit] };
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExprOrStm(binId, binOp.flavor === 'assignment' ? control_flow_graph_1.CfgVertexType.Statement : control_flow_graph_1.CfgVertexType.Expression, { end: [binExit] }));
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(binId));
+    const fd = control_flow_graph_1.CfgEdge.makeFd();
     for (const exitPoint of lhs.exitPoints) {
         for (const entryPoint of rhs.entryPoints) {
-            result.graph.addEdge(entryPoint, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+            result.graph.addEdge(entryPoint, exitPoint, fd);
         }
     }
     for (const entryPoint of lhs.entryPoints) {
-        graph.addEdge(entryPoint, binOp.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entryPoint, binId, fd);
     }
     for (const exitPoint of rhs.exitPoints) {
-        graph.addEdge(binOp.info.id + '-exit', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(binExit, exitPoint, fd);
     }
     return result;
 }
 function cfgAccess(access, name, accessors) {
     const result = { ...name };
     const graph = result.graph;
-    graph.addVertex({ id: access.info.id, type: control_flow_graph_1.CfgVertexType.Expression, mid: name.exitPoints, end: [access.info.id + '-exit'] });
-    result.entryPoints = [access.info.id];
+    const accessId = access.info.id;
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExpressionWithEnd(accessId, { mid: name.exitPoints }));
+    result.entryPoints = [accessId];
     for (const entry of name.entryPoints) {
-        graph.addEdge(entry, access.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(entry, accessId, control_flow_graph_1.CfgEdge.makeFd());
     }
     result.exitPoints = name.exitPoints;
     for (const accessor of accessors) {
@@ -466,7 +488,7 @@ function cfgAccess(access, name, accessors) {
         graph.mergeWith(accessor.graph);
         for (const exitPoint of result.exitPoints) {
             for (const entry of accessor.entryPoints) {
-                graph.addEdge(entry, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+                graph.addEdge(entry, exitPoint, control_flow_graph_1.CfgEdge.makeFd());
             }
         }
         result.exitPoints = accessor.exitPoints;
@@ -475,58 +497,56 @@ function cfgAccess(access, name, accessors) {
         result.returns = result.returns.concat(accessor.returns);
     }
     for (const exitPoint of result.exitPoints) {
-        graph.addEdge(access.info.id + '-exit', exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(control_flow_graph_1.CfgVertex.toExitId(accessId), exitPoint, control_flow_graph_1.CfgEdge.makeFd());
     }
-    graph.addVertex({ id: access.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: access.info.id });
-    result.exitPoints = [access.info.id + '-exit'];
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(accessId));
+    result.exitPoints = [control_flow_graph_1.CfgVertex.toExitId(accessId)];
     return result;
 }
 function cfgUnaryOp(unary, operand) {
     const graph = operand.graph;
-    graph.addVertex({ id: unary.info.id, type: control_flow_graph_1.CfgVertexType.EndMarker, root: unary.info.id });
+    const unaryId = unary.info.id;
+    graph.addVertex(control_flow_graph_1.CfgVertex.makeMarker(unaryId, unaryId));
+    const fd = control_flow_graph_1.CfgEdge.makeFd();
     for (const entry of operand.exitPoints) {
-        graph.addEdge(unary.info.id, entry, { label: 0 /* CfgEdgeType.Fd */ });
+        graph.addEdge(unaryId, entry, fd);
     }
-    return { ...operand, graph, exitPoints: [unary.info.id] };
+    return { ...operand, graph, exitPoints: [unaryId] };
 }
 function cfgExprList(node, _grouping, expressions) {
+    const nodeId = node.info.id;
     const result = {
         graph: new control_flow_graph_1.ControlFlowGraph(),
         breaks: [],
         nexts: [],
         returns: [],
-        exitPoints: [node.info.id],
-        entryPoints: [node.info.id]
+        exitPoints: [nodeId],
+        entryPoints: [nodeId]
     };
-    const vtx = { id: node.info.id, type: control_flow_graph_1.CfgVertexType.Expression, end: [] };
+    const vtx = control_flow_graph_1.CfgVertex.makeExpression(nodeId);
     result.graph.addVertex(vtx);
+    const fd = control_flow_graph_1.CfgEdge.makeFd();
     for (const expression of expressions) {
         for (const previousExitPoint of result.exitPoints) {
             for (const entryPoint of expression.entryPoints) {
-                result.graph.addEdge(entryPoint, previousExitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+                result.graph.addEdge(entryPoint, previousExitPoint, fd);
             }
         }
         result.graph.mergeWith(expression.graph);
-        result.breaks = result.breaks.concat(expression.breaks);
-        result.nexts = result.nexts.concat(expression.nexts);
-        result.returns = result.returns.concat(expression.returns);
+        result.breaks.push(...expression.breaks);
+        result.nexts.push(...expression.nexts);
+        result.returns.push(...expression.returns);
         result.exitPoints = expression.exitPoints;
     }
+    const exitId = control_flow_graph_1.CfgVertex.toExitId(nodeId);
     if (result.exitPoints.length > 0) {
-        result.graph.addVertex({
-            id: node.info.id + '-exit',
-            type: control_flow_graph_1.CfgVertexType.EndMarker,
-            root: node.info.id
-        });
-        vtx.end = [node.info.id + '-exit'];
-    }
-    else {
-        vtx.end = undefined;
+        result.graph.addVertex(control_flow_graph_1.CfgVertex.makeExitMarker(nodeId));
+        control_flow_graph_1.CfgVertex.setEnd(vtx, [exitId]);
     }
     for (const exit of result.exitPoints) {
-        result.graph.addEdge(node.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        result.graph.addEdge(exitId, exit, fd);
     }
-    result.exitPoints = result.exitPoints.length > 0 ? [node.info.id + '-exit'] : [];
+    result.exitPoints = result.exitPoints.length > 0 ? [exitId] : [];
     return result;
 }
 /**
@@ -541,13 +561,13 @@ function cfg2quads(cfg, config) {
         vertices: [...cfg.graph.vertices().entries()]
             .map(([id, v]) => ({
             id,
-            children: v.children
+            children: control_flow_graph_1.CfgVertex.getChildren(v)
         })),
         edges: [...cfg.graph.edges()].flatMap(([fromId, targets]) => [...targets].map(([toId, info]) => ({
             from: fromId,
             to: toId,
-            type: info.label,
-            when: info.when
+            type: control_flow_graph_1.CfgEdge.getType(info),
+            when: control_flow_graph_1.CfgEdge.getWhen(info)
         }))),
         entryPoints: cfg.entryPoints,
         exitPoints: cfg.exitPoints,

package/control-flow/happens-before.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.happensBefore = happensBefore;
 const logic_1 = require("../util/logic");
+const control_flow_graph_1 = require("./control-flow-graph");
 /**
  * Determines if node `a` happens before node `b` in the control flow graph.
  */
@@ -23,7 +24,7 @@ function happensBefore(cfg, a, b) {
         }
         visited.add(current);
         for (const [id, t] of cfg.outgoingEdges(current) ?? []) {
-            const marker = t.label === 1 /* CfgEdgeType.Cd */ ? `${t.caused}-exit` : useCd;
+            const marker = control_flow_graph_1.CfgEdge.isControlDependency(t) ? control_flow_graph_1.CfgVertex.toExitId(control_flow_graph_1.CfgEdge.unpackCause(t)) : useCd;
             stack.push([id, useCd ?? marker]);
         }
     }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SemanticCfgGuidedVisitor = void 0;
+const control_flow_graph_1 = require("./control-flow-graph");
 const dfg_cfg_guided_visitor_1 = require("./dfg-cfg-guided-visitor");
 const dfg_get_origin_1 = require("../dataflow/origin/dfg-get-origin");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
@@ -132,7 +133,7 @@ class SemanticCfgGuidedVisitor extends dfg_cfg_guided_visitor_1.DataflowAwareCfg
      */
     visitUnknown(vertex) {
         super.visitUnknown(vertex);
-        const ast = this.getNormalizedAst(vertex.id);
+        const ast = this.getNormalizedAst(control_flow_graph_1.CfgVertex.getId(vertex));
         if (ast && ast.type === type_1.RType.ExpressionList && ast.info.parent === undefined) {
             this.onProgram(ast);
         }

package/control-flow/simple-visitor.js

@@ -30,9 +30,10 @@ visitor) {
         }
         else if (hasBb) {
             const get = graph.getVertex(current);
-            if (get?.type === control_flow_graph_1.CfgVertexType.Block) {
-                for (const e of get.elems.toReversed()) {
-                    queue.push(e.id);
+            if (control_flow_graph_1.CfgVertex.isBlock(get)) {
+                const elems = control_flow_graph_1.CfgVertex.getBasicBlockElements(get);
+                for (const e of elems.toReversed()) {
+                    queue.push(control_flow_graph_1.CfgVertex.getId(e));
                 }
             }
         }
@@ -70,9 +71,10 @@ visitor) {
         }
         else if (hasBb) {
             const get = graph.getVertex(current);
-            if (get?.type === control_flow_graph_1.CfgVertexType.Block) {
-                for (const e of get.elems.toReversed()) {
-                    queue.push(e.id);
+            if (control_flow_graph_1.CfgVertex.isBlock(get)) {
+                const elems = control_flow_graph_1.CfgVertex.getBasicBlockElements(get);
+                for (const e of elems.toReversed()) {
+                    queue.push(control_flow_graph_1.CfgVertex.getId(e));
                 }
             }
         }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SyntaxAwareCfgGuidedVisitor = void 0;
+const control_flow_graph_1 = require("./control-flow-graph");
 const basic_cfg_guided_visitor_1 = require("./basic-cfg-guided-visitor");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const assert_1 = require("../util/assert");
@@ -25,7 +26,7 @@ class SyntaxAwareCfgGuidedVisitor extends basic_cfg_guided_visitor_1.BasicCfgGui
         this.onExprOrStmtNode(node);
     }
     onExprOrStmtNode(node) {
-        const astVertex = this.getNormalizedAst(node.id);
+        const astVertex = this.getNormalizedAst(control_flow_graph_1.CfgVertex.getId(node));
         if (!astVertex) {
             return;
         }