@eagleoutice/flowr 1.3.11

package/dataflow/v1/graph/graph.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataflowGraph = void 0;
+const assert_1 = require("../../../util/assert");
+const environments_1 = require("../../common/environments");
+const log_1 = require("../../../util/log");
+const edge_1 = require("./edge");
+const diff_1 = require("./diff");
+/**
+ * The dataflow graph holds the dataflow information found within the given AST.
+ * We differentiate the directed edges in {@link EdgeType} and the vertices indicated by {@link DataflowGraphVertexArgument}
+ *
+ * The vertices of the graph are organized in a hierarchical fashion, with a function-definition node containing the node ids of its subgraph.
+ * However, all *edges* are hoisted at the top level in the form of an (attributed) adjacency list.
+ * After the dataflow analysis, all sources and targets of the edges *must* be part of the vertices.
+ * However, this does not have to hold during the construction as edges may point from or to vertices which are yet to be constructed.
+ *
+ * All methods return the modified graph to allow for chaining.
+ */
+class DataflowGraph {
+    static DEFAULT_ENVIRONMENT = (0, environments_1.initializeCleanEnvironments)();
+    /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
+    rootVertices = new Set();
+    /** All vertices in the complete graph (including those nested in function definition) */
+    vertexInformation = new Map();
+    /** All edges in the complete graph (including those nested in function definition) */
+    edgeInformation = new Map();
+    /**
+     * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
+     *
+     * @param id                      - The id of the node to get
+     * @param includeDefinedFunctions - If true this will search function definitions as well and not just the toplevel
+     * @returns the node info for the given id (if it exists)
+     */
+    get(id, includeDefinedFunctions = true) {
+        // if we do not want to include function definitions, only retrieve the value if the id is part of the root vertices
+        const vertex = includeDefinedFunctions || this.rootVertices.has(id) ? this.vertexInformation.get(id) : undefined;
+        return vertex === undefined ? undefined : [vertex, this.outgoingEdges(id) ?? new Map()];
+    }
+    outgoingEdges(id) {
+        return this.edgeInformation.get(id);
+    }
+    ingoingEdges(id) {
+        const edges = new Map();
+        for (const [source, outgoing] of this.edgeInformation.entries()) {
+            if (outgoing.has(id)) {
+                edges.set(source, outgoing.get(id));
+            }
+        }
+        return edges;
+    }
+    /**
+   * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
+   * @returns the ids of all toplevel vertices in the graph together with their vertex information
+     *
+     * @see #edges
+   */
+    *vertices(includeDefinedFunctions) {
+        if (includeDefinedFunctions) {
+            yield* this.vertexInformation.entries();
+        }
+        else {
+            for (const id of this.rootVertices) {
+                yield [id, this.vertexInformation.get(id)];
+            }
+        }
+    }
+    /**
+     * @returns the ids of all edges in the graph together with their edge information
+     *
+     * @see #vertices
+     */
+    *edges() {
+        yield* this.edgeInformation.entries();
+    }
+    /**
+     * Returns true if the graph contains a node with the given id.
+     *
+     * @param id                      - The id to check for
+     * @param includeDefinedFunctions - If true this will check function definitions as well and not just the toplevel
+     */
+    hasNode(id, includeDefinedFunctions) {
+        return includeDefinedFunctions ? this.vertexInformation.has(id) : this.rootVertices.has(id);
+    }
+    /**
+     * Returns true if the root level of the graph contains a node with the given id.
+     */
+    isRoot(id) {
+        return this.rootVertices.has(id);
+    }
+    rootIds() {
+        return this.rootVertices;
+    }
+    /**
+   * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
+   *
+     * @param vertex - The vertex to add
+     * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds | root vertices} of the graph.
+     *                 This is probably only of use, when you construct dataflow graphs for tests.
+     *
+   * @see DataflowGraphVertexInfo
+   * @see DataflowGraphVertexArgument
+   */
+    addVertex(vertex, asRoot = true) {
+        const oldVertex = this.vertexInformation.get(vertex.id);
+        if (oldVertex !== undefined) {
+            (0, assert_1.guard)(oldVertex.name === vertex.name, 'vertex names must match for the same id if added');
+            return this;
+        }
+        // keep a clone of the original environment
+        const environment = vertex.environment === undefined ? DataflowGraph.DEFAULT_ENVIRONMENT : (0, environments_1.cloneEnvironments)(vertex.environment);
+        this.vertexInformation.set(vertex.id, {
+            ...vertex,
+            when: vertex.when ?? 'always',
+            environment
+        });
+        if (asRoot) {
+            this.rootVertices.add(vertex.id);
+        }
+        return this;
+    }
+    /**
+   * Will insert a new edge into the graph,
+   * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
+   * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
+   * <p>
+   * If you omit the last argument but set promote, this will make the edge `maybe` if at least one of the {@link IdentifierReference | references} or {@link DataflowGraphVertexInfo | nodes} has a used flag of `maybe`.
+   * Promote will probably only be used internally and not by tests etc.
+   */
+    addEdge(from, to, type, attribute, promote = false) {
+        const fromId = typeof from === 'object' ? from.nodeId : from;
+        const toId = typeof to === 'object' ? to.nodeId : to;
+        if (fromId === toId) {
+            log_1.log.trace(`ignoring self-edge from ${fromId} to ${toId} (${type}, ${attribute ?? '?'}, ${promote ? 'y' : 'n'})`);
+            return this;
+        }
+        if (promote) {
+            attribute ??= from.used === 'maybe' ? 'maybe' : to.used;
+            // reduce the load on attribute checks
+            if (attribute !== 'maybe') {
+                const fromInfo = this.get(fromId, true);
+                if (fromInfo?.[0].when === 'maybe') {
+                    log_1.log.trace(`automatically promoting edge from ${fromId} to ${toId} as maybe because at least one of the nodes is maybe`);
+                    attribute = 'maybe';
+                }
+                else {
+                    const toInfo = this.get(toId, true);
+                    if (toInfo?.[0].when === 'maybe') {
+                        log_1.log.trace(`automatically promoting edge from ${fromId} to ${toId} as maybe because at least one of the nodes is maybe`);
+                        attribute = 'maybe';
+                    }
+                }
+            }
+        }
+        (0, assert_1.guard)(attribute !== undefined, 'attribute must be set');
+        const edge = { types: new Set([type]), attribute };
+        const existingFrom = this.edgeInformation.get(fromId);
+        const edgeInFrom = existingFrom?.get(toId);
+        if (edgeInFrom === undefined) {
+            if (existingFrom === undefined) {
+                this.edgeInformation.set(fromId, new Map([[toId, edge]]));
+            }
+            else {
+                existingFrom.set(toId, edge);
+            }
+            // sort (on id so that sorting is the same, independent of the attribute)
+            const bidirectional = type === 'same-read-read' || type === 'same-def-def' || type === 'relates';
+            if (bidirectional) {
+                const existingTo = this.edgeInformation.get(toId);
+                if (existingTo === undefined) {
+                    this.edgeInformation.set(toId, new Map([[fromId, edge]]));
+                }
+                else {
+                    existingTo.set(fromId, edge);
+                }
+            }
+            else if (type === 'defines-on-call') {
+                const otherEdge = { ...edge,
+                    types: new Set([edge_1.EdgeType.DefinedByOnCall])
+                };
+                const existingTo = this.edgeInformation.get(toId);
+                if (existingTo === undefined) {
+                    this.edgeInformation.set(toId, new Map([[fromId, otherEdge]]));
+                }
+                else {
+                    existingTo.set(fromId, otherEdge);
+                }
+            }
+        }
+        else {
+            if (attribute === 'maybe') {
+                // as the data is shared, we can just set it for one direction
+                edgeInFrom.attribute = 'maybe';
+            }
+            if (!edgeInFrom.types.has(type)) {
+                // adding the type
+                edgeInFrom.types.add(type);
+            }
+        }
+        return this;
+    }
+    /**
+     * Merges the other graph into *this* one (in-place). The return value is only for convenience.
+     *
+     * @param otherGraph        - The graph to merge into this one
+     * @param mergeRootVertices - If false, this will only merge the vertices and edges but exclude the root vertices this is probably only of use
+     * 													  in the context of function definitions
+     */
+    mergeWith(otherGraph, mergeRootVertices = true) {
+        if (otherGraph === undefined) {
+            return this;
+        }
+        // merge root ids
+        if (mergeRootVertices) {
+            for (const root of otherGraph.rootVertices) {
+                this.rootVertices.add(root);
+            }
+        }
+        for (const [id, info] of otherGraph.vertexInformation) {
+            const currentInfo = this.vertexInformation.get(id);
+            this.vertexInformation.set(id, currentInfo === undefined ? info : mergeNodeInfos(currentInfo, info));
+        }
+        this.mergeEdges(otherGraph);
+        return this;
+    }
+    mergeEdges(otherGraph) {
+        for (const [id, edges] of otherGraph.edgeInformation.entries()) {
+            for (const [target, edge] of edges) {
+                const existing = this.edgeInformation.get(id);
+                if (existing === undefined) {
+                    this.edgeInformation.set(id, new Map([[target, edge]]));
+                }
+                else {
+                    const get = existing.get(target);
+                    if (get === undefined) {
+                        existing.set(target, edge);
+                    }
+                    else {
+                        get.types = new Set([...get.types, ...edge.types]);
+                        if (edge.attribute === 'maybe') {
+                            get.attribute = 'maybe';
+                        }
+                    }
+                }
+            }
+        }
+    }
+    equals(other, diff = false, names = { left: 'left', right: 'right' }) {
+        const report = (0, diff_1.diffOfDataflowGraphs)({ name: names.left, graph: this }, { name: names.right, graph: other });
+        if (diff) {
+            return report;
+        }
+        else {
+            return report.isEqual();
+        }
+    }
+    /**
+     * Marks a vertex in the graph to be a definition
+     * @param reference - The reference to the vertex to mark as definition
+     */
+    setDefinitionOfVertex(reference) {
+        const got = this.get(reference.nodeId, true);
+        (0, assert_1.guard)(got !== undefined, () => `node must be defined for ${JSON.stringify(reference)} to set definition scope to ${reference.scope}`);
+        const [node] = got;
+        if (node.tag === 'function-definition' || node.tag === 'variable-definition') {
+            (0, assert_1.guard)(node.scope === reference.scope, () => `node ${JSON.stringify(node)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
+            (0, assert_1.guard)(node.when === reference.used || node.when === 'maybe' || reference.used === 'maybe', () => `node ${JSON.stringify(node)} must not be previously defined at position or have same scope for ${JSON.stringify(reference)}`);
+            node.scope = reference.scope;
+            node.when = reference.used === 'maybe' ? 'maybe' : node.when;
+        }
+        else {
+            this.vertexInformation.set(reference.nodeId, {
+                ...node,
+                tag: 'variable-definition',
+                scope: reference.scope,
+            });
+        }
+    }
+}
+exports.DataflowGraph = DataflowGraph;
+function mergeNodeInfos(current, next) {
+    (0, assert_1.guard)(current.tag === next.tag, () => `nodes to be joined for the same id must have the same tag, but ${JSON.stringify(current)} vs ${JSON.stringify(next)}`);
+    (0, assert_1.guard)(current.name === next.name, () => `nodes to be joined for the same id must have the same name, but ${JSON.stringify(current)} vs ${JSON.stringify(next)}`);
+    (0, assert_1.guard)(current.environment === next.environment, 'nodes to be joined for the same id must have the same environment');
+    if (current.tag === 'variable-definition') {
+        (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
+    }
+    else if (current.tag === 'function-call') {
+        (0, assert_1.guard)((0, diff_1.equalFunctionArguments)(current.args, next.args), 'nodes to be joined for the same id must have the same function call information');
+    }
+    else if (current.tag === 'function-definition') {
+        (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
+        (0, assert_1.guard)((0, diff_1.equalExitPoints)(current.exitPoints, next.exitPoints), 'nodes to be joined must have same exist points');
+    }
+    // make a copy
+    return { ...current };
+}
+//# sourceMappingURL=graph.js.map

package/dataflow/v1/graph/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./graph"), exports);
+__exportStar(require("./edge"), exports);
+__exportStar(require("./vertex"), exports);
+__exportStar(require("./diff"), exports);
+//# sourceMappingURL=index.js.map

package/dataflow/v1/graph/quads.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.df2quads = void 0;
+const quads_1 = require("../../../util/quads");
+/**
+ * @see cfg2quads
+ * @see serialize2quads
+ * @see graph2quads
+ */
+function df2quads(graph, config) {
+    return (0, quads_1.graph2quads)({
+        rootIds: [...graph.rootIds()],
+        vertices: [...graph.vertices(true)]
+            .map(([id, v]) => ({
+            ...v,
+            id
+        })),
+        edges: [...graph.edges()].flatMap(([fromId, targets]) => [...targets].map(([toId, info]) => ({
+            from: fromId,
+            to: toId,
+            type: [...info.types],
+            when: info.attribute
+        })))
+    }, config);
+}
+exports.df2quads = df2quads;
+//# sourceMappingURL=quads.js.map

package/dataflow/v1/graph/vertex.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=vertex.js.map

package/dataflow/v1/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataflowLogger = void 0;
+const log_1 = require("../../util/log");
+exports.dataflowLogger = log_1.log.getSubLogger({ name: 'dataflow' });
+__exportStar(require("./graph"), exports);
+__exportStar(require("./extractor"), exports);
+__exportStar(require("../common/environments/environment"), exports);
+__exportStar(require("../../util/mermaid/dfg"), exports);
+//# sourceMappingURL=index.js.map

package/dataflow/v1/internal/info.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeCleanDataflowInformation = void 0;
+const graph_1 = require("../graph");
+function initializeCleanDataflowInformation(data) {
+    return {
+        unknownReferences: [],
+        in: [],
+        out: [],
+        scope: data.activeScope,
+        environments: data.environments,
+        graph: new graph_1.DataflowGraph()
+    };
+}
+exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
+//# sourceMappingURL=info.js.map

package/dataflow/v1/internal/linker.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkCircularRedefinitionsWithinALoop = exports.linkInputs = exports.getAllLinkedFunctionDefinitions = exports.linkFunctionCalls = exports.linkArgumentsOnCall = exports.linkReadVariablesInSameScopeWithNames = exports.produceNameSharedIdMap = exports.linkIngoingVariablesInSameScope = void 0;
+const environments_1 = require("../../common/environments");
+const defaultmap_1 = require("../../../util/defaultmap");
+const assert_1 = require("../../../util/assert");
+const log_1 = require("../../../util/log");
+const slicing_1 = require("../../../slicing");
+const index_1 = require("../index");
+const scopes_1 = require("../../common/environments/scopes");
+function linkIngoingVariablesInSameScope(graph, references) {
+    const nameIdShares = produceNameSharedIdMap(references);
+    linkReadVariablesInSameScopeWithNames(graph, nameIdShares);
+}
+exports.linkIngoingVariablesInSameScope = linkIngoingVariablesInSameScope;
+function produceNameSharedIdMap(references) {
+    const nameIdShares = new defaultmap_1.DefaultMap(() => []);
+    for (const reference of references) {
+        nameIdShares.get(reference.name).push(reference);
+    }
+    return nameIdShares;
+}
+exports.produceNameSharedIdMap = produceNameSharedIdMap;
+function linkReadVariablesInSameScopeWithNames(graph, nameIdShares) {
+    for (const ids of nameIdShares.values()) {
+        if (ids.length <= 1) {
+            continue;
+        }
+        const base = ids[0];
+        for (let i = 1; i < ids.length; i++) {
+            graph.addEdge(base.nodeId, ids[i].nodeId, index_1.EdgeType.SameReadRead, 'always', true);
+        }
+    }
+}
+exports.linkReadVariablesInSameScopeWithNames = linkReadVariablesInSameScopeWithNames;
+function specialReturnFunction(info, graph, id) {
+    if (info.args.length > 1) {
+        index_1.dataflowLogger.error(`expected up to one argument for return, but got ${info.args.length}`);
+    }
+    for (const arg of info.args) {
+        if (Array.isArray(arg)) {
+            if (arg[1] !== '<value>') {
+                graph.addEdge(id, arg[1], index_1.EdgeType.Returns, 'always');
+            }
+        }
+        else if (arg !== '<value>') {
+            graph.addEdge(id, arg, index_1.EdgeType.Returns, 'always');
+        }
+    }
+}
+function linkArgumentsOnCall(args, params, graph) {
+    const nameArgMap = new Map(args.filter(Array.isArray));
+    const nameParamMap = new Map(params.map(p => [p.name.content, p]));
+    const specialDotParameter = params.find(p => p.special);
+    // all parameters matched by name
+    const matchedParameters = new Set();
+    // first map names
+    for (const [name, arg] of nameArgMap) {
+        if (arg === '<value>') {
+            index_1.dataflowLogger.trace(`skipping value argument for ${name}`);
+            continue;
+        }
+        const param = nameParamMap.get(name);
+        if (param !== undefined) {
+            index_1.dataflowLogger.trace(`mapping named argument "${name}" to parameter "${param.name.content}"`);
+            graph.addEdge(arg.nodeId, param.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+            matchedParameters.add(name);
+        }
+        else if (specialDotParameter !== undefined) {
+            index_1.dataflowLogger.trace(`mapping named argument "${name}" to dot-dot-dot parameter`);
+            graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+        }
+    }
+    const remainingParameter = params.filter(p => !matchedParameters.has(p.name.content));
+    const remainingArguments = args.filter(a => !Array.isArray(a));
+    for (let i = 0; i < remainingArguments.length; i++) {
+        const arg = remainingArguments[i];
+        if (arg === '<value>' || arg === 'empty') {
+            index_1.dataflowLogger.trace(`skipping value argument for ${i}`);
+            continue;
+        }
+        if (remainingParameter.length <= i) {
+            if (specialDotParameter !== undefined) {
+                index_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to dot-dot-dot parameter`);
+                graph.addEdge(arg.nodeId, specialDotParameter.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+            }
+            else {
+                index_1.dataflowLogger.error(`skipping argument ${i} as there is no corresponding parameter - R should block that`);
+            }
+            continue;
+        }
+        const param = remainingParameter[i];
+        index_1.dataflowLogger.trace(`mapping unnamed argument ${i} (id: ${arg.nodeId}) to parameter "${param.name.content}"`);
+        graph.addEdge(arg.nodeId, param.name.info.id, index_1.EdgeType.DefinesOnCall, 'always');
+    }
+}
+exports.linkArgumentsOnCall = linkArgumentsOnCall;
+function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRootId, callArgs, finalGraph) {
+    // we get them by just choosing the rhs of the definition
+    const linkedFunction = idMap.get(targetId);
+    if (linkedFunction === undefined) {
+        index_1.dataflowLogger.trace(`no function definition found for ${functionCallName} (${functionRootId})`);
+        return;
+    }
+    if (linkedFunction.type !== "RFunctionDefinition" /* RType.FunctionDefinition */) {
+        index_1.dataflowLogger.trace(`function call definition base ${functionCallName} does not lead to a function definition (${functionRootId}) but got ${linkedFunction.type}`);
+        return;
+    }
+    index_1.dataflowLogger.trace(`linking arguments for ${functionCallName} (${functionRootId}) to ${JSON.stringify(linkedFunction.location)}`);
+    linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
+}
+function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions) {
+    const edges = graph.get(id, true);
+    (0, assert_1.guard)(edges !== undefined, () => `id ${id} must be present in graph`);
+    const functionDefinitionReadIds = [...edges[1]].filter(([_, e]) => e.types.has(index_1.EdgeType.Reads) || e.types.has(index_1.EdgeType.Calls) || e.types.has(index_1.EdgeType.Relates)).map(([target, _]) => target);
+    const functionDefs = getAllLinkedFunctionDefinitions(new Set(functionDefinitionReadIds), graph);
+    for (const def of functionDefs.values()) {
+        (0, assert_1.guard)(def.tag === 'function-definition', () => `expected function definition, but got ${def.tag}`);
+        if (info.environment !== undefined) {
+            // for each open ingoing reference, try to resolve it here, and if so add a read edge from the call to signal that it reads it
+            for (const ingoing of def.subflow.in) {
+                const defs = (0, environments_1.resolveByName)(ingoing.name, scopes_1.LocalScope, info.environment);
+                if (defs === undefined) {
+                    continue;
+                }
+                for (const def of defs) {
+                    graph.addEdge(id, def, index_1.EdgeType.Reads, 'always');
+                }
+            }
+        }
+        const exitPoints = def.exitPoints;
+        for (const exitPoint of exitPoints) {
+            graph.addEdge(id, exitPoint, index_1.EdgeType.Returns, 'always');
+        }
+        index_1.dataflowLogger.trace(`recording expression-list-level call from ${info.name} to ${def.name}`);
+        graph.addEdge(id, def.id, index_1.EdgeType.Calls, 'always');
+        linkFunctionCallArguments(def.id, idMap, def.name, id, info.args, graph);
+    }
+    if (thisGraph.isRoot(id)) {
+        calledFunctionDefinitions.push({ functionCall: id, called: [...functionDefs.values()] });
+    }
+}
+/**
+ * Returns the called functions within the current graph, which can be used to merge the environments with the call.
+ * Furthermore, it links the corresponding arguments.
+ */
+function linkFunctionCalls(graph, idMap, functionCalls, thisGraph) {
+    const calledFunctionDefinitions = [];
+    for (const [id, info] of functionCalls) {
+        (0, assert_1.guard)(info.tag === 'function-call', () => `encountered non-function call in function call linkage ${JSON.stringify(info)}`);
+        if (info.name === 'return') {
+            specialReturnFunction(info, graph, id);
+            graph.addEdge(id, environments_1.BuiltIn, index_1.EdgeType.Calls, 'always');
+            continue;
+        }
+        linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
+    }
+    return calledFunctionDefinitions;
+}
+exports.linkFunctionCalls = linkFunctionCalls;
+function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
+    const potential = [...functionDefinitionReadIds];
+    const visited = new Set();
+    const result = new Map();
+    while (potential.length > 0) {
+        const currentId = potential.pop();
+        if (currentId === environments_1.BuiltIn) {
+            // do not traverse builtins
+            slicing_1.slicerLogger.trace('skipping builtin function definition during collection');
+            continue;
+        }
+        const currentInfo = dataflowGraph.get(currentId, true);
+        if (currentInfo === undefined) {
+            slicing_1.slicerLogger.trace('skipping unknown link');
+            continue;
+        }
+        visited.add(currentId);
+        const outgoingEdges = [...currentInfo[1]];
+        const returnEdges = outgoingEdges.filter(([_, e]) => e.types.has(index_1.EdgeType.Returns));
+        if (returnEdges.length > 0) {
+            // only traverse return edges and do not follow calls etc. as this indicates that we have a function call which returns a result, and not the function call itself
+            potential.push(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
+            continue;
+        }
+        const followEdges = outgoingEdges.filter(([_, e]) => e.types.has(index_1.EdgeType.Reads) || e.types.has(index_1.EdgeType.DefinedBy) || e.types.has(index_1.EdgeType.DefinedByOnCall) || e.types.has(index_1.EdgeType.Relates));
+        if (currentInfo[0].subflow !== undefined) {
+            result.set(currentId, currentInfo[0]);
+        }
+        // trace all joined reads
+        potential.push(...followEdges.map(([target]) => target).filter(id => !visited.has(id)));
+    }
+    return result;
+}
+exports.getAllLinkedFunctionDefinitions = getAllLinkedFunctionDefinitions;
+/**
+ * This method links a set of read variables to definitions in an environment.
+ *
+ * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
+ * @param scope                              - The scope in which the linking shall happen (probably the active scope of {@link DataflowProcessorInformation})
+ * @param environmentInformation             - The environment information to link against
+ * @param givenInputs                        - The existing list of inputs that might be extended
+ * @param graph                              - The graph to enter the found links
+ * @param maybeForRemaining                  - Each input that can not be linked, will be added to `givenInputs`. If this flag is `true`, it will be marked as `maybe`.
+ *
+ * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
+ */
+function linkInputs(referencesToLinkAgainstEnvironment, scope, environmentInformation, givenInputs, graph, maybeForRemaining) {
+    for (const bodyInput of referencesToLinkAgainstEnvironment) {
+        const probableTarget = (0, environments_1.resolveByName)(bodyInput.name, scope, environmentInformation);
+        if (probableTarget === undefined) {
+            log_1.log.trace(`found no target for ${bodyInput.name} in ${scope}`);
+            if (maybeForRemaining) {
+                bodyInput.used = 'maybe';
+            }
+            givenInputs.push(bodyInput);
+        }
+        else {
+            for (const target of probableTarget) {
+                // we can stick with maybe even if readId.attribute is always
+                graph.addEdge(bodyInput, target, index_1.EdgeType.Reads, undefined, true);
+            }
+        }
+    }
+    // data.graph.get(node.id).definedAtPosition = false
+    return givenInputs;
+}
+exports.linkInputs = linkInputs;
+/** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
+ * e.g. with:
+ * ```R
+ * for(i in 1:10) {
+ *  x_1 <- x_2 + 1
+ * }
+ * ```
+ * `x_2` must get a read marker to `x_1` as `x_1` is the active redefinition in the second loop iteration.
+ */
+function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
+    // first we preprocess out so that only the last definition of a given identifier survives
+    // this implicitly assumes that the outgoing references are ordered
+    const lastOutgoing = new Map();
+    for (const out of outgoing) {
+        lastOutgoing.set(out.name, out);
+    }
+    for (const [name, targets] of openIns.entries()) {
+        for (const out of lastOutgoing.values()) {
+            if (out.name === name) {
+                for (const target of targets) {
+                    graph.addEdge(target.nodeId, out.nodeId, index_1.EdgeType.Reads, 'maybe');
+                }
+            }
+        }
+    }
+}
+exports.linkCircularRedefinitionsWithinALoop = linkCircularRedefinitionsWithinALoop;
+//# sourceMappingURL=linker.js.map