@eagleoutice/flowr 2.2.11 → 2.2.13

package/control-flow/diff-cfg.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffOfControlFlowGraphs = diffOfControlFlowGraphs;
+const json_1 = require("../util/json");
+const diff_graph_1 = require("../util/diff-graph");
+const diff_1 = require("../util/diff");
+const control_flow_graph_1 = require("./control-flow-graph");
+const arrays_1 = require("../util/collections/arrays");
+/**
+ * Compare two control flow graphs and return a report on the differences.
+ * If you simply want to check whether they equal, use {@link GraphDifferenceReport#isEqual|`<result>.isEqual()`}.
+ *
+ * @see {@link diffOfDataflowGraphs} - for dataflow graphs
+ */
+function diffOfControlFlowGraphs(left, right, config) {
+    if (left.graph === right.graph) {
+        return new diff_graph_1.GraphDifferenceReport();
+    }
+    const ctx = (0, diff_graph_1.initDiffContext)(left, right, config);
+    diffDataflowGraphs(ctx);
+    return ctx.report;
+}
+function diffDataflowGraphs(ctx) {
+    diffRootVertices(ctx);
+    diffVertices(ctx);
+    diffOutgoingEdges(ctx);
+}
+function diffRootVertices(ctx) {
+    (0, diff_1.setDifference)(ctx.left.rootIds(), ctx.right.rootIds(), {
+        ...ctx,
+        position: `${ctx.position}Root vertices differ in graphs. `
+    });
+}
+function diffVertices(ctx) {
+    const lVert = [...ctx.left.vertices(false)].map(([id, info]) => [id, info]);
+    const rVert = [...ctx.right.vertices(false)].map(([id, info]) => [id, info]);
+    if (lVert.length < rVert.length && !ctx.config.leftIsSubgraph
+        || lVert.length > rVert.length && !ctx.config.rightIsSubgraph) {
+        ctx.report.addComment(`Detected different number of vertices! ${ctx.leftname} has ${lVert.length}, ${ctx.rightname} has ${rVert.length}`);
+    }
+    for (const [id, lInfo] of lVert) {
+        const rInfo = ctx.right.getVertex(id, false);
+        if (rInfo === undefined) {
+            if (!ctx.config.rightIsSubgraph) {
+                ctx.report.addComment(`Vertex ${id} is not present in ${ctx.rightname}`, { tag: 'vertex', id });
+            }
+            continue;
+        }
+        if (lInfo.type !== rInfo.type) {
+            ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.type} vs. ${ctx.rightname}: ${rInfo.type}`, {
+                tag: 'vertex',
+                id
+            });
+        }
+        if (lInfo.kind !== undefined || rInfo.kind !== undefined) {
+            if (lInfo.kind !== rInfo.kind) {
+                ctx.report.addComment(`Vertex ${id} differs in kinds. ${ctx.leftname}: ${String(lInfo.kind)} vs ${ctx.rightname}: ${String(rInfo.kind)}`, {
+                    tag: 'vertex',
+                    id
+                });
+            }
+        }
+        if (lInfo.callTargets !== undefined || rInfo.callTargets !== undefined) {
+            (0, diff_1.setDifference)(new Set(lInfo.callTargets ?? []), new Set(rInfo.callTargets ?? []), {
+                ...ctx,
+                position: `${ctx.position}Vertex ${id} differs in call targets. `
+            });
+        }
+        if (lInfo.elems !== undefined || rInfo.elems !== undefined) {
+            if (!(0, arrays_1.arrayEqual)((lInfo.elems ?? []), (rInfo.elems ?? []), control_flow_graph_1.equalVertex)) {
+                ctx.report.addComment(`Vertex ${id} differs in elems.\n  ${ctx.leftname}: ${JSON.stringify(lInfo.elems)}\n  vs\n  ${ctx.rightname}: ${JSON.stringify(rInfo.elems)}`, { tag: 'vertex', id });
+            }
+        }
+        (0, diff_1.setDifference)(new Set(lInfo.mid ?? []), new Set(rInfo.mid ?? []), {
+            ...ctx,
+            position: `${ctx.position}Vertex ${id} differs in attached mid markers. `
+        });
+        (0, diff_1.setDifference)(new Set(lInfo.end ?? []), new Set(rInfo.end ?? []), {
+            ...ctx,
+            position: `${ctx.position}Vertex ${id} differs in attached end markers. `
+        });
+        if (lInfo.root !== rInfo.root) {
+            ctx.report.addComment(`Vertex ${id} differs in root. ${ctx.leftname}: ${JSON.stringify(lInfo.root)} vs ${ctx.rightname}: ${JSON.stringify(rInfo.root)}`, {
+                tag: 'vertex',
+                id
+            });
+        }
+        (0, diff_1.setDifference)(new Set(lInfo.children), new Set(rInfo.children), {
+            ...ctx,
+            position: `${ctx.position}Vertex ${id} differs in chilren. `
+        });
+    }
+}
+function diffOutgoingEdges(ctx) {
+    const lEdges = new Map([...ctx.left.edges()]);
+    const rEdges = new Map([...ctx.right.edges()]);
+    if (lEdges.size < rEdges.size && !ctx.config.leftIsSubgraph || lEdges.size > rEdges.size && !ctx.config.rightIsSubgraph) {
+        ctx.report.addComment(`Detected different number of edges! ${ctx.leftname} has ${lEdges.size} (${JSON.stringify(lEdges, json_1.jsonReplacer)}). ${ctx.rightname} has ${rEdges.size} ${JSON.stringify(rEdges, json_1.jsonReplacer)}`);
+    }
+    for (const [id, edge] of lEdges) {
+        /* This has nothing to do with the subset relation as we verify this in the same graph.
+         * Yet we still do the check as a subgraph may not have to have all source vertices for edges.
+         */
+        if (!ctx.left.hasVertex(id)) {
+            if (!ctx.config.leftIsSubgraph) {
+                ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.leftname}. This means that the graph contains an edge but not the corresponding vertex.`);
+                continue;
+            }
+        }
+        diffEdges(ctx, id, edge, rEdges.get(id));
+    }
+    // just to make it both ways in case the length differs
+    for (const [id, edge] of rEdges) {
+        if (!ctx.right.hasVertex(id)) {
+            if (!ctx.config.rightIsSubgraph) {
+                ctx.report.addComment(`The source ${id} of edges ${JSON.stringify(edge, json_1.jsonReplacer)} is not present in ${ctx.rightname}. This means that the graph contains an edge but not the corresponding vertex.`);
+                continue;
+            }
+        }
+        if (!ctx.config.leftIsSubgraph && !lEdges.has(id)) {
+            diffEdges(ctx, id, undefined, edge);
+        }
+        /* otherwise, we already cover the edge above */
+    }
+}
+function diffEdge(edge, otherEdge, ctx, id, target) {
+    if (edge.label !== otherEdge.label) {
+        ctx.report.addComment(`Edge ${id}->${target} differs in labels. ${ctx.leftname}: ${edge.label} vs ${ctx.rightname}: ${otherEdge.label}`, { tag: 'edge', from: id, to: target });
+    }
+    if (edge.caused !== otherEdge.caused) {
+        ctx.report.addComment(`Edge ${id}->${target} differs in caused. ${ctx.leftname}: ${JSON.stringify(edge.caused)} vs ${ctx.rightname}: ${JSON.stringify(otherEdge.caused)}`, { tag: 'edge', from: id, to: target });
+    }
+    if (edge.when !== otherEdge.when) {
+        ctx.report.addComment(`Edge ${id}->${target} differs in when. ${ctx.leftname}: ${JSON.stringify(edge.when)} vs ${ctx.rightname}: ${JSON.stringify(otherEdge.when)}`, { tag: 'edge', from: id, to: target });
+    }
+}
+function diffEdges(ctx, id, lEdges, rEdges) {
+    if (lEdges === undefined || rEdges === undefined) {
+        if ((lEdges === undefined && !ctx.config.leftIsSubgraph)
+            || (rEdges === undefined && !ctx.config.rightIsSubgraph)) {
+            ctx.report.addComment(`Vertex ${id} has undefined outgoing edges. ${ctx.leftname}: ${JSON.stringify(lEdges, json_1.jsonReplacer)} vs ${ctx.rightname}: ${JSON.stringify(rEdges, json_1.jsonReplacer)}`, { tag: 'vertex', id });
+        }
+        return;
+    }
+    if (lEdges.size < rEdges.size && !ctx.config.leftIsSubgraph
+        || lEdges.size > rEdges.size && !ctx.config.rightIsSubgraph) {
+        ctx.report.addComment(`Vertex ${id} differs in number of outgoing edges. ${ctx.leftname}: [${[...lEdges.keys()].join(',')}] vs ${ctx.rightname}: [${[...rEdges.keys()].join(',')}] `, { tag: 'vertex', id });
+    }
+    // order independent compare
+    for (const [target, edge] of lEdges) {
+        const otherEdge = rEdges.get(target);
+        if (otherEdge === undefined) {
+            if (!ctx.config.rightIsSubgraph) {
+                ctx.report.addComment(`Target of ${id}->${target} in ${ctx.leftname} is not present in ${ctx.rightname}`, { tag: 'edge', from: id, to: target });
+            }
+            continue;
+        }
+        diffEdge(edge, otherEdge, ctx, id, target);
+    }
+}
+//# sourceMappingURL=diff-cfg.js.map

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

@@ -0,0 +1,30 @@
+import type { QuadSerializationConfiguration } from '../util/quads';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowGraph } from '../dataflow/graph/graph';
+import type { ControlFlowInformation } from './control-flow-graph';
+import type { CfgSimplificationPassName } from './cfg-simplification';
+/**
+ * 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,
+ * especially because it focuses on intra-procedural analysis.
+ *
+ * @param ast             - the normalized AST
+ * @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;
+/**
+ * Simplified version of {@link extractCFG} that is much quicker, but much simpler!
+ */
+export declare function extractSimpleCfg<Info = ParentInformation>(ast: NormalizedAst<Info>): ControlFlowInformation<import("./control-flow-graph").CfgSimpleVertex>;
+export declare const ResolvedCallSuffix = "-resolved-call-exit";
+/**
+ * Convert a cfg to RDF quads.
+ *
+ * @see {@link df2quads}
+ * @see {@link serialize2quads}
+ * @see {@link graph2quads}
+ */
+export declare function cfg2quads(cfg: ControlFlowInformation, config: QuadSerializationConfiguration): string;

package/control-flow/extract-cfg.js

@@ -0,0 +1,475 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResolvedCallSuffix = void 0;
+exports.extractCFG = extractCFG;
+exports.extractSimpleCfg = extractSimpleCfg;
+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");
+const control_flow_graph_1 = require("./control-flow-graph");
+const cfg_simplification_1 = require("./cfg-simplification");
+const assert_1 = require("../util/assert");
+const cfgFolds = {
+    foldNumber: cfgLeaf(control_flow_graph_1.CfgVertexType.Expression),
+    foldString: cfgLeaf(control_flow_graph_1.CfgVertexType.Expression),
+    foldLogical: cfgLeaf(control_flow_graph_1.CfgVertexType.Expression),
+    foldSymbol: cfgLeaf(control_flow_graph_1.CfgVertexType.Expression),
+    foldAccess: cfgAccess,
+    foldBinaryOp: cfgBinaryOp,
+    foldPipe: cfgBinaryOp,
+    foldUnaryOp: cfgUnaryOp,
+    other: {
+        foldComment: cfgIgnore,
+        foldLineDirective: cfgIgnore
+    },
+    loop: {
+        foldFor: cfgFor,
+        foldRepeat: cfgRepeat,
+        foldWhile: cfgWhile,
+        foldBreak: cfgBreak,
+        foldNext: cfgNext
+    },
+    foldIfThenElse: cfgIfThenElse,
+    foldExprList: cfgExprList,
+    functions: {
+        foldFunctionDefinition: cfgFunctionDefinition,
+        foldFunctionCall: cfgFunctionCall,
+        foldParameter: cfgArgumentOrParameter,
+        foldArgument: cfgArgumentOrParameter
+    }
+};
+function dataflowCfgFolds(dataflowGraph) {
+    return {
+        ...cfgFolds,
+        functions: {
+            ...cfgFolds.functions,
+            foldFunctionCall: cfgFunctionCallWithDataflow(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,
+ * especially because it focuses on intra-procedural analysis.
+ *
+ * @param ast             - the normalized AST
+ * @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);
+}
+/**
+ * Simplified version of {@link extractCFG} that is much quicker, but much simpler!
+ */
+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] };
+    };
+}
+function cfgBreak(leaf) {
+    return { ...cfgLeaf(control_flow_graph_1.CfgVertexType.Statement)(leaf), breaks: [leaf.info.id], exitPoints: [] };
+}
+function cfgNext(leaf) {
+    return { ...cfgLeaf(control_flow_graph_1.CfgVertexType.Statement)(leaf), nexts: [leaf.info.id], exitPoints: [] };
+}
+function cfgIgnore(_leaf) {
+    return { graph: new control_flow_graph_1.ControlFlowGraph(), breaks: [], nexts: [], returns: [], exitPoints: [], entryPoints: [] };
+}
+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 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.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 */ });
+    }
+    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 });
+    }
+    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 });
+    }
+    for (const entryPoint of condition.entryPoints) {
+        graph.addEdge(entryPoint, ifNode.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const exit of [...then.exitPoints, ...otherwise?.exitPoints ?? []]) {
+        graph.addEdge(ifNode.info.id + '-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 });
+    }
+    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]
+    };
+}
+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 });
+    for (const entryPoint of body.entryPoints) {
+        graph.addEdge(entryPoint, repeat.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    // loops automatically
+    for (const next of [...body.nexts, ...body.exitPoints]) {
+        graph.addEdge(repeat.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const breakPoint of body.breaks) {
+        graph.addEdge(repeat.info.id + '-exit', breakPoint, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: [repeat.info.id + '-exit'], entryPoints: [repeat.info.id] };
+}
+function cfgWhile(whileLoop, condition, body) {
+    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.mergeWith(body.graph);
+    for (const entry of condition.entryPoints) {
+        graph.addEdge(entry, whileLoop.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const exit of condition.exitPoints) {
+        graph.addEdge(whileLoop.info.id + '-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 });
+    }
+    for (const next of [...body.nexts, ...body.exitPoints]) {
+        graph.addEdge(whileLoop.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const breakPoint of body.breaks) {
+        graph.addEdge(whileLoop.info.id + '-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] };
+}
+function cfgFor(forLoop, variable, vector, body) {
+    const graph = variable.graph;
+    graph.addVertex({ id: forLoop.info.id, type: identifyMayStatementType(forLoop), end: [forLoop.info.id + '-exit'], mid: [forLoop.info.id + '-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 */ });
+    }
+    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' });
+    for (const exit of variable.exitPoints) {
+        graph.addEdge(forLoop.info.id + '-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 });
+    }
+    for (const next of [...body.nexts, ...body.exitPoints]) {
+        graph.addEdge(forLoop.info.id, next, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const breakPoint of body.breaks) {
+        graph.addEdge(forLoop.info.id + '-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',
+            type: control_flow_graph_1.CfgVertexType.EndMarker,
+            root: forLoop.info.id
+        });
+        graph.addEdge(forLoop.info.id + '-exit', forLoop.info.id + '-head', { label: 1 /* CfgEdgeType.Cd */, when: convert_values_1.RFalse, caused: forLoop.info.id });
+    }
+    return { graph, breaks: [], nexts: [], returns: body.returns, exitPoints: isNotEndless ? [forLoop.info.id + '-exit'] : [], entryPoints: [forLoop.info.id] };
+}
+function cfgFunctionDefinition(fn, params, body) {
+    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'] });
+    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 */ });
+        }
+        for (const exit of param.exitPoints) {
+            graph.addEdge(fn.info.id + '-params', exit, { label: 0 /* CfgEdgeType.Fd */ });
+        }
+    }
+    if (params.length === 0) {
+        graph.addEdge(fn.info.id + '-params', fn.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const entry of body.entryPoints) {
+        graph.addEdge(entry, fn.info.id + '-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 */ });
+    }
+    return { graph: graph, breaks: [], nexts: [], returns: [], exitPoints: [fn.info.id], entryPoints: [fn.info.id] };
+}
+function cfgFunctionCall(call, name, args, exit = 'exit') {
+    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] });
+    for (const entryPoint of name.entryPoints) {
+        graph.addEdge(entryPoint, call.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    graph.addVertex({ id: call.info.id + '-name', kind: 'name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: call.info.id });
+    for (const exitPoint of name.exitPoints) {
+        graph.addEdge(call.info.id + '-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'];
+    for (const arg of args) {
+        if (arg === r_function_call_1.EmptyArgument) {
+            continue;
+        }
+        graph.mergeWith(arg.graph);
+        info.breaks = info.breaks.concat(arg.breaks);
+        info.nexts = info.nexts.concat(arg.nexts);
+        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 */ });
+            }
+        }
+        lastArgExits = arg.exitPoints;
+    }
+    for (const exit of lastArgExits) {
+        graph.addEdge(call.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    // should not contain any breaks, nexts, or returns, (except for the body if something like 'break()')
+    return info;
+}
+exports.ResolvedCallSuffix = '-resolved-call-exit';
+function cfgFunctionCallWithDataflow(graph) {
+    return (call, name, args) => {
+        const baseCFG = cfgFunctionCall(call, name, args);
+        /* try to resolve the call and link the target definitions */
+        const targets = (0, linker_1.getAllFunctionCallTargets)(call.info.id, graph);
+        const exits = [];
+        const callVertex = baseCFG.graph.getVertex(call.info.id);
+        (0, assert_1.guard)(callVertex !== undefined, 'cfgFunctionCallWithDataflow: call vertex not found');
+        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');
+            }
+        }
+        if (exits.length > 0) {
+            baseCFG.graph.addVertex({
+                id: call.info.id + exports.ResolvedCallSuffix,
+                type: control_flow_graph_1.CfgVertexType.EndMarker,
+                root: call.info.id
+            });
+            for (const exit of [...baseCFG.exitPoints, ...exits]) {
+                baseCFG.graph.addEdge(call.info.id + exports.ResolvedCallSuffix, exit, { label: 0 /* CfgEdgeType.Fd */ });
+            }
+            return {
+                ...baseCFG,
+                exitPoints: [call.info.id + exports.ResolvedCallSuffix]
+            };
+        }
+        else {
+            return baseCFG;
+        }
+    };
+}
+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] };
+    graph.addVertex({ id: node.info.id, type: control_flow_graph_1.CfgVertexType.Expression, mid: [node.info.id + '-before-value'], end: [node.info.id + '-exit'] });
+    let currentExitPoint = [node.info.id];
+    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 */ });
+        }
+        currentExitPoint = name.exitPoints;
+    }
+    graph.addVertex({ id: node.info.id + '-before-value', kind: 'before-value', type: control_flow_graph_1.CfgVertexType.MidMarker, root: node.info.id });
+    for (const exitPoints of currentExitPoint) {
+        graph.addEdge(node.info.id + '-before-value', exitPoints, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    currentExitPoint = [node.info.id + '-before-value'];
+    if (value) {
+        graph.mergeWith(value.graph);
+        info.breaks = info.breaks.concat(value.breaks);
+        info.nexts = info.nexts.concat(value.nexts);
+        info.returns = info.returns.concat(value.returns);
+        for (const exitPoint of currentExitPoint) {
+            for (const entry of value.entryPoints) {
+                graph.addEdge(entry, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+            }
+        }
+        currentExitPoint = value.exitPoints;
+    }
+    graph.addVertex({ id: node.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: node.info.id });
+    for (const exit of currentExitPoint) {
+        graph.addEdge(node.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    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, ...rhs.breaks], nexts: [...lhs.nexts, ...rhs.nexts], returns: [...lhs.returns, ...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 });
+    for (const exitPoint of lhs.exitPoints) {
+        for (const entryPoint of rhs.entryPoints) {
+            result.graph.addEdge(entryPoint, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+        }
+    }
+    for (const entryPoint of lhs.entryPoints) {
+        graph.addEdge(entryPoint, binOp.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const exitPoint of rhs.exitPoints) {
+        graph.addEdge(binOp.info.id + '-exit', exitPoint, { label: 0 /* CfgEdgeType.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: [access.info.id + '-after-name'], end: [access.info.id + '-exit'] });
+    result.entryPoints = [access.info.id];
+    for (const entry of name.entryPoints) {
+        graph.addEdge(entry, access.info.id, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    for (const exit of name.exitPoints) {
+        graph.addEdge(access.info.id + '-after-name', exit, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    graph.addVertex({ id: access.info.id + '-after-name', kind: 'after-name', type: control_flow_graph_1.CfgVertexType.MidMarker, root: access.info.id });
+    result.exitPoints = [access.info.id + '-after-name'];
+    for (const accessor of accessors) {
+        if (accessor === r_function_call_1.EmptyArgument) {
+            continue;
+        }
+        graph.mergeWith(accessor.graph);
+        for (const exitPoint of result.exitPoints) {
+            for (const entry of accessor.entryPoints) {
+                graph.addEdge(entry, exitPoint, { label: 0 /* CfgEdgeType.Fd */ });
+            }
+        }
+        result.exitPoints = accessor.exitPoints;
+        result.breaks = result.breaks.concat(accessor.breaks);
+        result.nexts = result.nexts.concat(accessor.nexts);
+        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.addVertex({ id: access.info.id + '-exit', type: control_flow_graph_1.CfgVertexType.EndMarker, root: access.info.id });
+    result.exitPoints = [access.info.id + '-exit'];
+    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 });
+    for (const entry of operand.exitPoints) {
+        graph.addEdge(unary.info.id, entry, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    return { ...operand, graph, exitPoints: [unary.info.id] };
+}
+function cfgExprList(node, _grouping, expressions) {
+    const result = {
+        graph: new control_flow_graph_1.ControlFlowGraph(),
+        breaks: [],
+        nexts: [],
+        returns: [],
+        exitPoints: [node.info.id],
+        entryPoints: [node.info.id]
+    };
+    const vtx = { id: node.info.id, type: control_flow_graph_1.CfgVertexType.Expression, end: [] };
+    result.graph.addVertex(vtx);
+    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.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.exitPoints = expression.exitPoints;
+    }
+    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;
+    }
+    for (const exit of result.exitPoints) {
+        result.graph.addEdge(node.info.id + '-exit', exit, { label: 0 /* CfgEdgeType.Fd */ });
+    }
+    result.exitPoints = result.exitPoints.length > 0 ? [node.info.id + '-exit'] : [];
+    return result;
+}
+/**
+ * Convert a cfg to RDF quads.
+ *
+ * @see {@link df2quads}
+ * @see {@link serialize2quads}
+ * @see {@link graph2quads}
+ */
+function cfg2quads(cfg, config) {
+    return (0, quads_1.graph2quads)({
+        rootIds: [...cfg.graph.rootIds()],
+        vertices: [...cfg.graph.vertices().entries()]
+            .map(([id, v]) => ({
+            id,
+            children: v.children
+        })),
+        edges: [...cfg.graph.edges()].flatMap(([fromId, targets]) => [...targets].map(([toId, info]) => ({
+            from: fromId,
+            to: toId,
+            type: info.label,
+            when: info.when
+        }))),
+        entryPoints: cfg.entryPoints,
+        exitPoints: cfg.exitPoints,
+        breaks: cfg.breaks,
+        nexts: cfg.nexts,
+        returns: cfg.returns
+    }, config);
+}
+//# sourceMappingURL=extract-cfg.js.map

package/control-flow/happens-before.d.ts

@@ -0,0 +1,7 @@
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { Ternary } from '../util/logic';
+import type { ControlFlowGraph } from './control-flow-graph';
+/**
+ * Determines if node `a` happens before node `b` in the control flow graph.
+ */
+export declare function happensBefore(cfg: ControlFlowGraph, a: NodeId, b: NodeId): Ternary;