@eagleoutice/flowr 1.3.11

package/dataflow/v1/internal/process/access.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAccess = void 0;
+const processor_1 = require("../../processor");
+const environments_1 = require("../../../common/environments");
+const graph_1 = require("../../graph");
+function processAccess(node, data) {
+    const processedAccessed = (0, processor_1.processDataflowFor)(node.accessed, data);
+    const nextGraph = processedAccessed.graph;
+    const outgoing = processedAccessed.out;
+    const ingoing = processedAccessed.in;
+    let environments = processedAccessed.environments;
+    const accessedNodes = processedAccessed.unknownReferences;
+    if (node.operator === '[' || node.operator === '[[') {
+        for (const access of node.access) {
+            if (access === null || access.value === undefined) {
+                continue;
+            }
+            data = { ...data, environments };
+            const processedAccess = (0, processor_1.processDataflowFor)(access, data);
+            nextGraph.mergeWith(processedAccess.graph);
+            // outgoing.push()
+            // we link to *out* instead of *in*, as access uses arguments for parsing and the arguments are defined
+            for (const newIn of [...processedAccess.out, ...processedAccess.unknownReferences]) {
+                for (const accessedNode of accessedNodes) {
+                    nextGraph.addEdge(accessedNode, newIn, graph_1.EdgeType.Reads, 'always');
+                }
+            }
+            ingoing.push(...processedAccess.in, ...processedAccess.unknownReferences);
+            environments = processedAccess.environments;
+        }
+    }
+    return {
+        /*
+     * keep active nodes in case of assignments etc.
+     * We make them maybe as a kind of hack.
+     * This way when using
+     * ```ts
+     * a[[1]] <- 3
+     * a[[2]] <- 4
+     * a
+     * ```
+     * the read for a will use both accesses as potential definitions and not just the last one!
+     */
+        unknownReferences: (0, environments_1.makeAllMaybe)(processedAccessed.unknownReferences, nextGraph, environments),
+        in: ingoing,
+        out: outgoing,
+        environments: environments,
+        scope: data.activeScope,
+        graph: nextGraph
+    };
+}
+exports.processAccess = processAccess;
+//# sourceMappingURL=access.js.map

package/dataflow/v1/internal/process/expression-list.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processExpressionList = void 0;
+/**
+ * Processes a list of expressions joining their dataflow graphs accordingly.
+ * @module
+ */
+const info_1 = require("../info");
+const r_bridge_1 = require("../../../../r-bridge");
+const processor_1 = require("../../processor");
+const environments_1 = require("../../../common/environments");
+const linker_1 = require("../linker");
+const defaultmap_1 = require("../../../../util/defaultmap");
+const graph_1 = require("../../graph");
+const index_1 = require("../../index");
+const assert_1 = require("../../../../util/assert");
+const dotDotDotAccess = /\.\.\d+/;
+function linkReadNameToWriteIfPossible(read, data, environments, listEnvironments, remainingRead, nextGraph) {
+    const readName = dotDotDotAccess.test(read.name) ? '...' : read.name;
+    const probableTarget = (0, environments_1.resolveByName)(readName, data.activeScope, environments);
+    // record if at least one has not been defined
+    if (probableTarget === undefined || probableTarget.some(t => !listEnvironments.has(t.nodeId))) {
+        if (remainingRead.has(readName)) {
+            remainingRead.get(readName)?.push(read);
+        }
+        else {
+            remainingRead.set(readName, [read]);
+        }
+    }
+    // keep it, for we have no target, as read-ids are unique within same fold, this should work for same links
+    // we keep them if they are defined outside the current parent and maybe throw them away later
+    if (probableTarget === undefined) {
+        return;
+    }
+    for (const target of probableTarget) {
+        // we can stick with maybe even if readId.attribute is always
+        nextGraph.addEdge(read, target, index_1.EdgeType.Reads, undefined, true);
+    }
+}
+function processNextExpression(currentElement, data, environments, listEnvironments, remainingRead, nextGraph) {
+    // all inputs that have not been written until know, are read!
+    for (const read of [...currentElement.in, ...currentElement.unknownReferences]) {
+        linkReadNameToWriteIfPossible(read, data, environments, listEnvironments, remainingRead, nextGraph);
+    }
+    // add same variable reads for deferred if they are read previously but not dependent
+    for (const writeTarget of currentElement.out) {
+        const writeName = writeTarget.name;
+        const resolved = (0, environments_1.resolveByName)(writeName, data.activeScope, environments);
+        if (resolved !== undefined) {
+            // write-write
+            for (const target of resolved) {
+                nextGraph.addEdge(target, writeTarget, index_1.EdgeType.SameDefDef, undefined, true);
+            }
+        }
+    }
+}
+function updateSideEffectsForCalledFunctions(calledEnvs, environments, nextGraph) {
+    for (const { functionCall, called } of calledEnvs) {
+        for (const calledFn of called) {
+            (0, assert_1.guard)(calledFn.tag === 'function-definition', 'called function must call a function definition');
+            // only merge the environments they have in common
+            let environment = calledFn.environment;
+            while (environment.level > environments.level) {
+                environment = (0, environments_1.popLocalEnvironment)(environment);
+            }
+            // update alle definitions to be defined at this function call
+            let current = environment.current;
+            while (current !== undefined) {
+                for (const definitions of current.memory.values()) {
+                    for (const def of definitions) {
+                        if (def.kind !== 'built-in-function') {
+                            nextGraph.addEdge(def.nodeId, functionCall, index_1.EdgeType.SideEffectOnCall, def.used);
+                        }
+                    }
+                }
+                current = current.parent;
+            }
+            // we update all definitions to be linked with the corresponding function call
+            environments = (0, environments_1.overwriteEnvironments)(environments, environment);
+        }
+    }
+    return environments;
+}
+function processExpressionList(exprList, data) {
+    const expressions = exprList.children;
+    index_1.dataflowLogger.trace(`processing expression list with ${expressions.length} expressions`);
+    if (expressions.length === 0) {
+        return (0, info_1.initializeCleanDataflowInformation)(data);
+    }
+    let environments = data.environments;
+    // used to detect if a "write" happens within the same expression list
+    const listEnvironments = new Set();
+    const remainingRead = new Map();
+    const nextGraph = new graph_1.DataflowGraph();
+    const out = [];
+    let expressionCounter = 0;
+    let foundNextOrBreak = false;
+    for (const expression of expressions) {
+        index_1.dataflowLogger.trace(`processing expression ${++expressionCounter} of ${expressions.length}`);
+        // use the current environments for processing
+        data = { ...data, environments };
+        const processed = (0, processor_1.processDataflowFor)(expression, data);
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- seems to be a bug in eslint
+        if (!foundNextOrBreak) {
+            (0, r_bridge_1.visitAst)(expression, n => {
+                // we should track returns more consistently
+                if (n.type === "RNext" /* RType.Next */ || n.type === "RBreak" /* RType.Break */) {
+                    foundNextOrBreak = true;
+                }
+                return n.type === "RForLoop" /* RType.ForLoop */ || n.type === "RWhileLoop" /* RType.WhileLoop */ || n.type === "RRepeatLoop" /* RType.RepeatLoop */ || n.type === "RFunctionDefinition" /* RType.FunctionDefinition */;
+            });
+        }
+        // if the expression contained next or break anywhere before the next loop, the overwrite should be an append because we do not know if the rest is executed
+        // update the environments for the next iteration with the previous writes
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- seems to be a bug in eslint
+        if (foundNextOrBreak) {
+            processed.out = (0, environments_1.makeAllMaybe)(processed.out, nextGraph, processed.environments);
+            processed.in = (0, environments_1.makeAllMaybe)(processed.in, nextGraph, processed.environments);
+            processed.unknownReferences = (0, environments_1.makeAllMaybe)(processed.unknownReferences, nextGraph, processed.environments);
+        }
+        nextGraph.mergeWith(processed.graph);
+        out.push(...processed.out);
+        index_1.dataflowLogger.trace(`expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
+        processNextExpression(processed, data, environments, listEnvironments, remainingRead, nextGraph);
+        const functionCallIds = [...processed.graph.vertices(true)]
+            .filter(([_, info]) => info.tag === 'function-call');
+        const calledEnvs = (0, linker_1.linkFunctionCalls)(nextGraph, data.completeAst.idMap, functionCallIds, processed.graph);
+        if (foundNextOrBreak) {
+            environments = (0, environments_1.overwriteEnvironments)(environments, processed.environments);
+        }
+        else {
+            environments = processed.environments;
+        }
+        // if the called function has global redefinitions, we have to keep them within our environment
+        environments = updateSideEffectsForCalledFunctions(calledEnvs, environments, nextGraph);
+        for (const { nodeId } of processed.out) {
+            listEnvironments.add(nodeId);
+        }
+    }
+    // now, we have to link same reads
+    (0, linker_1.linkReadVariablesInSameScopeWithNames)(nextGraph, new defaultmap_1.DefaultMap(() => [], remainingRead));
+    index_1.dataflowLogger.trace(`expression list exits with ${remainingRead.size} remaining read names`);
+    return {
+        /* no active nodes remain, they are consumed within the remaining read collection */
+        unknownReferences: [],
+        in: [...remainingRead.values()].flat(),
+        out,
+        environments,
+        scope: data.activeScope,
+        graph: nextGraph
+    };
+}
+exports.processExpressionList = processExpressionList;
+//# sourceMappingURL=expression-list.js.map

package/dataflow/v1/internal/process/functions/argument.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionArgument = exports.linkReadsForArgument = exports.UnnamedArgumentPrefix = void 0;
+const processor_1 = require("../../../processor");
+const r_bridge_1 = require("../../../../../r-bridge");
+const graph_1 = require("../../../graph");
+const scopes_1 = require("../../../../common/environments/scopes");
+exports.UnnamedArgumentPrefix = 'unnamed-argument-';
+function linkReadsForArgument(root, ingoingRefs, graph) {
+    const allIdsBeforeArguments = new Set((0, r_bridge_1.collectAllIds)(root, n => n.type === "RArgument" /* RType.Argument */ && n.info.id !== root.info.id));
+    const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
+    for (const ref of ingoingBeforeArgs) {
+        // link against the root reference currently I do not know how to deal with nested function calls otherwise
+        graph.addEdge(root.info.id, ref, graph_1.EdgeType.Reads, 'always');
+    }
+}
+exports.linkReadsForArgument = linkReadsForArgument;
+function processFunctionArgument(argument, data) {
+    const name = argument.name === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.name, data);
+    const value = argument.value === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.value, data);
+    // we do not keep the graph of the name, as this is no node that should ever exist
+    const graph = value?.graph ?? new graph_1.DataflowGraph();
+    const argContent = argument.name?.content;
+    const argumentName = argContent ?? `${exports.UnnamedArgumentPrefix}${argument.info.id}`;
+    graph.addVertex({ tag: 'use', id: argument.info.id, name: argumentName, environment: data.environments, when: 'always' });
+    const ingoingRefs = [...value?.unknownReferences ?? [], ...value?.in ?? [], ...(name === undefined ? [] : [...name.in])];
+    if (argument.value?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+        graph.addEdge(argument.info.id, argument.value.info.id, graph_1.EdgeType.Reads, 'always');
+    }
+    else {
+        // we only need to link against those which are not already bound to another function call argument
+        linkReadsForArgument(argument, [...ingoingRefs, ...value?.out ?? [] /* value may perform definitions */], graph);
+    }
+    return {
+        unknownReferences: [],
+        // active nodes of the name will be lost as they are only used to reference the corresponding parameter
+        in: ingoingRefs,
+        // , ...value.out, ...(name?.out ?? [])
+        out: [{ name: argumentName, scope: scopes_1.LocalScope, nodeId: argument.info.id, used: 'always' }],
+        graph: graph,
+        environments: value?.environments ?? data.environments,
+        scope: data.activeScope
+    };
+}
+exports.processFunctionArgument = processFunctionArgument;
+//# sourceMappingURL=argument.js.map

package/dataflow/v1/internal/process/functions/exit-points.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveExitPointsOfFunctionDefinition = void 0;
+const assert_1 = require("../../../../../util/assert");
+// TODO: wir wollen exit points für alle expression lists nicht nur für function definitions -> wir schlagen alle mit einer klappe :3
+function retrieveExitPointsOfFunctionDefinition(functionDefinition) {
+    const exitPoints = visitExitPoints(functionDefinition.body);
+    return exitPoints.knownIds.concat(exitPoints.potentialIds);
+}
+exports.retrieveExitPointsOfFunctionDefinition = retrieveExitPointsOfFunctionDefinition;
+// TODO: fold
+function visitExitPoints(node) {
+    const type = node.type;
+    switch (type) {
+        case "RExpressionList" /* RType.ExpressionList */:
+            return visitExpressionList(node);
+        case "RFunctionCall" /* RType.FunctionCall */:
+            // TODO: what if return is overwritten
+            if (node.flavor === 'named' && node.functionName.content === 'return') {
+                return {
+                    knownIds: [node.info.id],
+                    potentialIds: []
+                };
+            }
+            break;
+        case "RFunctionDefinition" /* RType.FunctionDefinition */:
+            // do not further investigate
+            break;
+        case "RForLoop" /* RType.ForLoop */:
+        case "RWhileLoop" /* RType.WhileLoop */:
+        case "RRepeatLoop" /* RType.RepeatLoop */:
+            // loops return invisible null, as we do not trace values, but they may contain return statements
+            return visitLoops(node);
+        case "RIfThenElse" /* RType.IfThenElse */:
+            return visitIf(node);
+        case "RPipe" /* RType.Pipe */:
+        case "RBinaryOp" /* RType.BinaryOp */:
+            // assignments return invisible rhs
+            return knownIdsOfChildren(node.info.id, node.lhs, node.rhs);
+        case "RUnaryOp" /* RType.UnaryOp */:
+            return knownIdsOfChildren(node.info.id, node.operand);
+        case "RParameter" /* RType.Parameter */:
+            return node.defaultValue ? knownIdsOfChildren(node.info.id, node.defaultValue) : { knownIds: [], potentialIds: [] };
+        case "RArgument" /* RType.Argument */:
+            return node.value ? knownIdsOfChildren(node.info.id, node.value) : { knownIds: [], potentialIds: [] };
+        case "RSymbol" /* RType.Symbol */:
+        case "RLogical" /* RType.Logical */:
+        case "RNumber" /* RType.Number */:
+        case "RString" /* RType.String */:
+        case "RAccess" /* RType.Access */:
+            // just use this node
+            break;
+        // contain noting to return/return `invisible(null)`
+        case "RComment" /* RType.Comment */:
+        case "RLineDirective" /* RType.LineDirective */:
+        case "RBreak" /* RType.Break */:
+        case "RNext" /* RType.Next */:
+            // TODO: wrong for loops
+            return { knownIds: [], potentialIds: [] };
+        default:
+            (0, assert_1.assertUnreachable)(type);
+    }
+    return {
+        knownIds: [],
+        potentialIds: [node.info.id]
+    };
+}
+// we use keepSelfAsPotential in order to track nodes like 2 + 3, which keep themselves as potential exit points if there are no knownIds
+function knownIdsOfChildren(keepSelfAsPotential, ...children) {
+    const knownIds = children.flatMap(child => visitExitPoints(child).knownIds);
+    return {
+        knownIds,
+        potentialIds: knownIds.length === 0 ? [keepSelfAsPotential] : []
+    };
+}
+function visitLoops(loop) {
+    const result = visitExitPoints(loop.body);
+    // conditions may contain return statements which we have to keep
+    let otherKnownIds = [];
+    if (loop.type === "RForLoop" /* RType.ForLoop */) {
+        otherKnownIds = visitExitPoints(loop.variable).knownIds;
+        otherKnownIds.push(...visitExitPoints(loop.vector).knownIds);
+    }
+    else if (loop.type === "RWhileLoop" /* RType.WhileLoop */) {
+        otherKnownIds = visitExitPoints(loop.condition).knownIds;
+    }
+    return {
+        knownIds: [...result.knownIds, ...otherKnownIds],
+        potentialIds: []
+    };
+}
+function visitExpressionList(node) {
+    const known = [];
+    let lastPotentialIds = [];
+    // we only keep the potential ids of the last expression, which is no comment
+    for (const child of node.children) {
+        const { knownIds, potentialIds } = visitExitPoints(child);
+        known.push(...knownIds);
+        if (child.type !== "RComment" /* RType.Comment */) {
+            lastPotentialIds = potentialIds;
+        }
+    }
+    return {
+        knownIds: known,
+        potentialIds: lastPotentialIds
+    };
+}
+function visitIf(node) {
+    // conditions can contain return statements
+    const known = visitExitPoints(node.condition).knownIds;
+    const potential = [];
+    const thenCase = visitExitPoints(node.then);
+    known.push(...thenCase.knownIds);
+    potential.push(...thenCase.potentialIds);
+    if (node.otherwise !== undefined) {
+        const otherwiseCase = visitExitPoints(node.otherwise);
+        known.push(...otherwiseCase.knownIds);
+        potential.push(...otherwiseCase.potentialIds);
+    }
+    return {
+        knownIds: known,
+        potentialIds: potential
+    };
+}
+//# sourceMappingURL=exit-points.js.map

package/dataflow/v1/internal/process/functions/function-call.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionCall = exports.UnnamedFunctionCallPrefix = void 0;
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../../common/environments");
+const assert_1 = require("../../../../../util/assert");
+const index_1 = require("../../../index");
+const linker_1 = require("../../linker");
+const scopes_1 = require("../../../../common/environments/scopes");
+exports.UnnamedFunctionCallPrefix = 'unnamed-function-call-';
+function processFunctionCall(functionCall, data) {
+    const named = functionCall.flavor === 'named';
+    const functionName = (0, processor_1.processDataflowFor)(named ? functionCall.functionName : functionCall.calledFunction, data);
+    let finalEnv = functionName.environments;
+    // arg env contains the environments with other args defined
+    let argEnv = functionName.environments;
+    const finalGraph = new index_1.DataflowGraph();
+    const callArgs = [];
+    const args = [];
+    const remainingReadInArgs = [];
+    const functionRootId = functionCall.info.id;
+    let functionCallName;
+    if (named) {
+        functionCallName = functionCall.functionName.content;
+        index_1.dataflowLogger.debug(`Using ${functionRootId} (name: ${functionCallName}) as root for the function call`);
+    }
+    else {
+        functionCallName = `${exports.UnnamedFunctionCallPrefix}${functionRootId}`;
+        index_1.dataflowLogger.debug(`Using ${functionRootId} as root for the unnamed function call`);
+        // we know, that it calls the toplevel:
+        finalGraph.addEdge(functionRootId, functionCall.calledFunction.info.id, index_1.EdgeType.Calls, 'always');
+        // keep the defined function
+        finalGraph.mergeWith(functionName.graph);
+    }
+    for (const arg of functionCall.arguments) {
+        if (arg === undefined) {
+            callArgs.push('empty');
+            args.push(undefined);
+            continue;
+        }
+        const processed = (0, processor_1.processDataflowFor)(arg, { ...data, environments: argEnv });
+        args.push(processed);
+        finalEnv = (0, environments_1.overwriteEnvironments)(finalEnv, processed.environments);
+        argEnv = (0, environments_1.overwriteEnvironments)(argEnv, processed.environments);
+        finalGraph.mergeWith(processed.graph);
+        (0, assert_1.guard)(processed.out.length > 0, () => `Argument ${JSON.stringify(arg)} has no out references, but needs one for the unnamed arg`);
+        if (arg.type !== "RArgument" /* RType.Argument */ || !arg.name) {
+            callArgs.push(processed.out[0]);
+        }
+        else {
+            callArgs.push([arg.name.content, processed.out[0]]);
+        }
+        // add an argument edge to the final graph
+        finalGraph.addEdge(functionRootId, processed.out[0], index_1.EdgeType.Argument, 'always');
+        // resolve reads within argument
+        for (const ingoing of [...processed.in, ...processed.unknownReferences]) {
+            const tryToResolve = (0, environments_1.resolveByName)(ingoing.name, scopes_1.LocalScope, argEnv);
+            if (tryToResolve === undefined) {
+                remainingReadInArgs.push(ingoing);
+            }
+            else {
+                for (const resolved of tryToResolve) {
+                    finalGraph.addEdge(ingoing.nodeId, resolved.nodeId, index_1.EdgeType.Reads, 'always');
+                }
+            }
+        }
+        if (arg.type === "RArgument" /* RType.Argument */ && arg.name !== undefined) {
+            argEnv = (0, environments_1.define)({ ...processed.out[0], definedAt: arg.info.id, kind: 'argument' }, scopes_1.LocalScope, argEnv);
+        }
+    }
+    finalGraph.addVertex({
+        tag: 'function-call',
+        id: functionRootId,
+        name: functionCallName,
+        environment: data.environments,
+        when: 'always',
+        scope: data.activeScope,
+        args: callArgs // same reference
+    });
+    const inIds = remainingReadInArgs;
+    inIds.push({ nodeId: functionRootId, name: functionCallName, scope: data.activeScope, used: 'always' });
+    if (!named) {
+        if (functionCall.calledFunction.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+            (0, linker_1.linkArgumentsOnCall)(callArgs, functionCall.calledFunction.parameters, finalGraph);
+        }
+        // push the called function to the ids:
+        inIds.push(...functionName.in, ...functionName.unknownReferences);
+    }
+    return {
+        unknownReferences: [],
+        in: inIds,
+        out: functionName.out, // we do not keep argument out as it has been linked by the function
+        graph: finalGraph,
+        environments: finalEnv,
+        scope: data.activeScope
+    };
+}
+exports.processFunctionCall = processFunctionCall;
+//# sourceMappingURL=function-call.js.map

package/dataflow/v1/internal/process/functions/function-definition.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionDefinition = void 0;
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../../common/environments");
+const linker_1 = require("../../linker");
+const index_1 = require("../../../index");
+const r_bridge_1 = require("../../../../../r-bridge");
+const exit_points_1 = require("./exit-points");
+const assert_1 = require("../../../../../util/assert");
+const scopes_1 = require("../../../../common/environments/scopes");
+function updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, data, functionDefinition) {
+    // track *all* function definitions - included those nested within the current graph
+    // try to resolve their 'in' by only using the lowest scope which will be popped after this definition
+    for (const [id, info] of subgraph.vertices(true)) {
+        if (info.tag !== 'function-definition') {
+            continue;
+        }
+        const ingoingRefs = info.subflow.in;
+        const remainingIn = [];
+        for (const ingoing of ingoingRefs) {
+            for (const exitPoint of exitPoints) {
+                const node = subgraph.get(exitPoint, true);
+                const env = (0, environments_1.initializeCleanEnvironments)();
+                env.current.memory = node === undefined ? outEnvironment.current.memory : node[0].environment.current.memory;
+                const resolved = (0, environments_1.resolveByName)(ingoing.name, data.activeScope, env);
+                if (resolved === undefined) {
+                    remainingIn.push(ingoing);
+                    continue;
+                }
+                index_1.dataflowLogger.trace(`Found ${resolved.length} references to open ref ${id} in closure of function definition ${functionDefinition.info.id}`);
+                for (const ref of resolved) {
+                    subgraph.addEdge(ingoing, ref, index_1.EdgeType.Reads, exitPoints.length > 1 ? 'maybe' : 'always');
+                }
+            }
+        }
+        index_1.dataflowLogger.trace(`Keeping ${remainingIn.length} references to open ref ${id} in closure of function definition ${functionDefinition.info.id}`);
+        info.subflow.in = [...new Set(remainingIn)];
+    }
+}
+function prepareFunctionEnvironment(data) {
+    let env = (0, environments_1.initializeCleanEnvironments)();
+    for (let i = 0; i < data.environments.level + 1 /* add another env */; i++) {
+        env = (0, environments_1.pushLocalEnvironment)(env);
+    }
+    return { ...data, environments: env };
+}
+/**
+ * Within something like `f <- function(a=b, m=3) { b <- 1; a; b <- 5; a + 1 }`
+ * `a` will be defined by `b` and `b`will be a promise object bound by the first definition of b it can find.
+ * This means, that this function returns `2` due to the first `b <- 1` definition.
+ * If the code would be `f <- function(a=b, m=3) { if(m > 3) { b <- 1; }; a; b <- 5; a + 1 }`, we need a link to `b <- 1` and `b <- 6`
+ * as `b` can be defined by either one of them.
+ * <p>
+ * <b>Currently we may be unable to narrow down every definition within the body as we have not implemented ways to track what covers a first definitions</b>
+ */
+function findPromiseLinkagesForParameters(parameters, readInParameters, parameterEnvs, body) {
+    // first we try to bind again within parameters - if we have it, fine
+    const remainingRead = [];
+    for (const read of readInParameters) {
+        const resolved = (0, environments_1.resolveByName)(read.name, scopes_1.LocalScope, parameterEnvs);
+        if (resolved !== undefined) {
+            for (const ref of resolved) {
+                parameters.addEdge(read, ref, index_1.EdgeType.Reads, 'always');
+            }
+            continue;
+        }
+        // if not resolved, link all outs within the body as potential reads
+        // regarding the sort we can ignore equality as nodeIds are unique
+        // we sort to get the lowest id - if it is an 'always' flag we can safely use it instead of all of them
+        const writingOuts = body.out.filter(o => o.name === read.name).sort((a, b) => a.nodeId < b.nodeId ? 1 : -1);
+        if (writingOuts.length === 0) {
+            remainingRead.push(read);
+            continue;
+        }
+        if (writingOuts[0].used === 'always') {
+            parameters.addEdge(read, writingOuts[0], index_1.EdgeType.Reads, 'always');
+            continue;
+        }
+        for (const out of writingOuts) {
+            parameters.addEdge(read, out, index_1.EdgeType.Reads, 'maybe');
+        }
+    }
+    return remainingRead;
+}
+function processFunctionDefinition(functionDefinition, data) {
+    index_1.dataflowLogger.trace(`Processing function definition with id ${functionDefinition.info.id}`);
+    const originalEnvironments = data.environments;
+    // within a function def we do not pass on the outer binds as they could be overwritten when called
+    data = prepareFunctionEnvironment(data);
+    const subgraph = new index_1.DataflowGraph();
+    let readInParameters = [];
+    for (const param of functionDefinition.parameters) {
+        const processed = (0, processor_1.processDataflowFor)(param, data);
+        subgraph.mergeWith(processed.graph);
+        const read = [...processed.in, ...processed.unknownReferences];
+        (0, linker_1.linkInputs)(read, data.activeScope, data.environments, readInParameters, subgraph, false);
+        data = { ...data, environments: (0, environments_1.overwriteEnvironments)(data.environments, processed.environments) };
+    }
+    const paramsEnvironments = data.environments;
+    const body = (0, processor_1.processDataflowFor)(functionDefinition.body, data);
+    // as we know, that parameters can not duplicate, we overwrite their environments (which is the correct behavior, if someone uses non-`=` arguments in functions)
+    const bodyEnvironment = body.environments;
+    readInParameters = findPromiseLinkagesForParameters(subgraph, readInParameters, paramsEnvironments, body);
+    const readInBody = [...body.in, ...body.unknownReferences];
+    // there is no uncertainty regarding the arguments, as if a function header is executed, so is its body
+    const remainingRead = (0, linker_1.linkInputs)(readInBody, data.activeScope, paramsEnvironments, readInParameters.slice(), body.graph, true /* functions do not have to be called */);
+    subgraph.mergeWith(body.graph);
+    index_1.dataflowLogger.trace(`Function definition with id ${functionDefinition.info.id} has ${remainingRead.length} remaining reads`);
+    // link same-def-def with arguments
+    for (const writeTarget of body.out) {
+        const writeName = writeTarget.name;
+        const resolved = (0, environments_1.resolveByName)(writeName, data.activeScope, paramsEnvironments);
+        if (resolved !== undefined) {
+            // write-write
+            for (const target of resolved) {
+                subgraph.addEdge(target, writeTarget, index_1.EdgeType.SameDefDef, undefined, true);
+            }
+        }
+    }
+    const outEnvironment = (0, environments_1.overwriteEnvironments)(paramsEnvironments, bodyEnvironment);
+    for (const read of remainingRead) {
+        subgraph.addVertex({ tag: 'use', id: read.nodeId, name: read.name, environment: outEnvironment, when: 'maybe' });
+    }
+    const flow = {
+        unknownReferences: [],
+        in: remainingRead,
+        out: [],
+        graph: new Set(subgraph.rootIds()),
+        environments: outEnvironment,
+        scope: data.activeScope
+    };
+    const exitPoints = (0, exit_points_1.retrieveExitPointsOfFunctionDefinition)(functionDefinition);
+    // if exit points are extra, we must link them to all dataflow nodes they relate to.
+    linkExitPointsInGraph(exitPoints, subgraph, data.completeAst.idMap, outEnvironment);
+    updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, data, functionDefinition);
+    const graph = new index_1.DataflowGraph().mergeWith(subgraph, false);
+    graph.addVertex({
+        tag: 'function-definition',
+        id: functionDefinition.info.id,
+        name: functionDefinition.info.id,
+        environment: (0, environments_1.popLocalEnvironment)(outEnvironment),
+        scope: data.activeScope,
+        when: 'always',
+        subflow: flow,
+        exitPoints
+    });
+    return {
+        unknownReferences: [] /* nothing escapes a function definition, but the function itself, will be forced in assignment: { nodeId: functionDefinition.info.id, scope: data.activeScope, used: 'always', name: functionDefinition.info.id as string } */,
+        in: [],
+        out: [],
+        graph,
+        environments: originalEnvironments,
+        scope: data.activeScope
+    };
+}
+exports.processFunctionDefinition = processFunctionDefinition;
+function linkExitPointsInGraph(exitPoints, graph, idMap, environment) {
+    for (const exitPoint of exitPoints) {
+        const exitPointNode = graph.get(exitPoint, true);
+        // if there already is an exit point it is either a variable or already linked
+        if (exitPointNode !== undefined) {
+            continue;
+        }
+        const nodeInAst = idMap.get(exitPoint);
+        (0, assert_1.guard)(nodeInAst !== undefined, `Could not find exit point node with id ${exitPoint} in ast`);
+        graph.addVertex({ tag: 'exit-point', id: exitPoint, name: `${nodeInAst.lexeme ?? '??'}`, when: 'always', environment });
+        const allIds = [...(0, r_bridge_1.collectAllIds)(nodeInAst)].filter(id => graph.get(id, true) !== undefined);
+        for (const relatedId of allIds) {
+            if (relatedId !== exitPoint) {
+                graph.addEdge(exitPoint, relatedId, index_1.EdgeType.Relates, 'always');
+            }
+        }
+    }
+}
+//# sourceMappingURL=function-definition.js.map