@eagleoutice/flowr 1.3.11

package/dataflow/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("../../../environments");
+const assert_1 = require("../../../../util/assert");
+const index_1 = require("../../../index");
+const linker_1 = require("../../linker");
+const scopes_1 = require("../../../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.name === undefined) {
+            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/internal/process/functions/function-definition.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RFunctionDefinition } from '../../../../r-bridge';
+export declare function processFunctionDefinition<OtherInfo>(functionDefinition: RFunctionDefinition<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/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("../../../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("../../../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

package/dataflow/internal/process/functions/parameter.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RParameter } from '../../../../r-bridge';
+export declare function processFunctionParameter<OtherInfo>(parameter: RParameter<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/parameter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionParameter = void 0;
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../environments");
+const log_1 = require("../../../../util/log");
+const graph_1 = require("../../../graph");
+const scopes_1 = require("../../../environments/scopes");
+function processFunctionParameter(parameter, data) {
+    const name = (0, processor_1.processDataflowFor)(parameter.name, data);
+    const defaultValue = parameter.defaultValue === undefined ? undefined : (0, processor_1.processDataflowFor)(parameter.defaultValue, data);
+    const graph = defaultValue !== undefined ? name.graph.mergeWith(defaultValue.graph) : name.graph;
+    const writtenNodes = name.unknownReferences.map(n => ({
+        ...n,
+        kind: 'parameter',
+        used: 'always',
+        definedAt: parameter.info.id,
+        scope: scopes_1.LocalScope
+    }));
+    let environments = name.environments;
+    for (const writtenNode of writtenNodes) {
+        log_1.log.trace(`parameter ${writtenNode.name} (${writtenNode.nodeId}) is defined at id ${writtenNode.definedAt} with ${defaultValue === undefined ? 'no default value' : ' no default value'}`);
+        graph.setDefinitionOfVertex(writtenNode);
+        environments = (0, environments_1.define)(writtenNode, scopes_1.LocalScope, environments);
+        if (defaultValue !== undefined) {
+            if (parameter.defaultValue?.type === "RFunctionDefinition" /* RType.FunctionDefinition */) {
+                graph.addEdge(writtenNode, parameter.defaultValue.info.id, graph_1.EdgeType.DefinedBy, 'maybe' /* default arguments can be overridden! */);
+            }
+            else {
+                const definedBy = [...defaultValue.in, ...defaultValue.unknownReferences];
+                for (const node of definedBy) {
+                    graph.addEdge(writtenNode, node, graph_1.EdgeType.DefinedBy, 'maybe' /* default arguments can be overridden! */);
+                }
+            }
+        }
+    }
+    return {
+        unknownReferences: [],
+        in: defaultValue === undefined ? [] : [...defaultValue.in, ...defaultValue.unknownReferences, ...name.in],
+        out: [...(defaultValue?.out ?? []), ...name.out, ...name.unknownReferences],
+        graph: graph,
+        environments: environments,
+        scope: data.activeScope
+    };
+}
+exports.processFunctionParameter = processFunctionParameter;
+//# sourceMappingURL=parameter.js.map

package/dataflow/internal/process/if-then-else.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../info';
+import { DataflowProcessorInformation } from '../../processor';
+import { ParentInformation, RIfThenElse } from '../../../r-bridge';
+export declare function processIfThenElse<OtherInfo>(ifThen: RIfThenElse<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/if-then-else.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIfThenElse = void 0;
+const processor_1 = require("../../processor");
+const environments_1 = require("../../environments");
+const linker_1 = require("../linker");
+function processIfThenElse(ifThen, data) {
+    const cond = (0, processor_1.processDataflowFor)(ifThen.condition, data);
+    data = { ...data, environments: cond.environments };
+    let then;
+    let makeThenMaybe = false;
+    if (ifThen.condition.lexeme !== 'FALSE') {
+        then = (0, processor_1.processDataflowFor)(ifThen.then, data);
+        if (ifThen.condition.lexeme !== 'TRUE') {
+            makeThenMaybe = true;
+        }
+    }
+    let otherwise;
+    let makeOtherwiseMaybe = false;
+    if (ifThen.otherwise !== undefined && ifThen.condition.lexeme !== 'TRUE') {
+        otherwise = (0, processor_1.processDataflowFor)(ifThen.otherwise, data);
+        if (ifThen.condition.lexeme !== 'FALSE') {
+            makeOtherwiseMaybe = true;
+        }
+    }
+    const nextGraph = cond.graph.mergeWith(then?.graph).mergeWith(otherwise?.graph);
+    const thenEnvironment = (0, environments_1.appendEnvironments)(cond.environments, then?.environments);
+    const finalEnvironment = otherwise ? (0, environments_1.appendEnvironments)(thenEnvironment, otherwise.environments) : thenEnvironment;
+    // again within an if-then-else we consider all actives to be read
+    const ingoing = [
+        ...cond.in,
+        ...(makeThenMaybe ? (0, environments_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment) : then?.in ?? []),
+        ...(makeOtherwiseMaybe ? (0, environments_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment) : otherwise?.in ?? []),
+        ...cond.unknownReferences,
+        ...(makeThenMaybe ? (0, environments_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment) : then?.unknownReferences ?? []),
+        ...(makeOtherwiseMaybe ? (0, environments_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment) : otherwise?.unknownReferences ?? []),
+    ];
+    // we assign all with a maybe marker
+    // we do not merge even if they appear in both branches because the maybe links will refer to different ids
+    const outgoing = [
+        ...cond.out,
+        ...(makeThenMaybe ? (0, environments_1.makeAllMaybe)(then?.out, nextGraph, finalEnvironment) : then?.out ?? []),
+        ...(makeOtherwiseMaybe ? (0, environments_1.makeAllMaybe)(otherwise?.out, nextGraph, finalEnvironment) : otherwise?.out ?? []),
+    ];
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    return {
+        unknownReferences: [],
+        in: ingoing,
+        out: outgoing,
+        environments: finalEnvironment,
+        graph: nextGraph,
+        scope: data.activeScope,
+    };
+}
+exports.processIfThenElse = processIfThenElse;
+//# sourceMappingURL=if-then-else.js.map

package/dataflow/internal/process/loops/for-loop.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RForLoop } from '../../../../r-bridge';
+export declare function processForLoop<OtherInfo>(loop: RForLoop<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/loops/for-loop.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processForLoop = void 0;
+const linker_1 = require("../../linker");
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../environments");
+const graph_1 = require("../../../graph");
+const scopes_1 = require("../../../environments/scopes");
+function processForLoop(loop, data) {
+    const variable = (0, processor_1.processDataflowFor)(loop.variable, data);
+    const vector = (0, processor_1.processDataflowFor)(loop.vector, data);
+    let headEnvironments = (0, environments_1.overwriteEnvironments)(vector.environments, variable.environments);
+    const headGraph = variable.graph.mergeWith(vector.graph);
+    const writtenVariable = variable.unknownReferences;
+    for (const write of writtenVariable) {
+        headEnvironments = (0, environments_1.define)({ ...write, used: 'always', definedAt: loop.info.id, kind: 'variable' }, scopes_1.LocalScope, headEnvironments);
+    }
+    data = { ...data, environments: headEnvironments };
+    const body = (0, processor_1.processDataflowFor)(loop.body, data);
+    const nextGraph = headGraph.mergeWith(body.graph);
+    const outEnvironments = (0, environments_1.appendEnvironments)(headEnvironments, body.environments);
+    // again within an if-then-else we consider all actives to be read
+    // currently i add it at the end, but is this correct?
+    const ingoing = [...vector.in, ...(0, environments_1.makeAllMaybe)(body.in, nextGraph, outEnvironments), ...vector.unknownReferences, ...(0, environments_1.makeAllMaybe)(body.unknownReferences, nextGraph, outEnvironments)];
+    // now we have to bind all open reads with the given name to the locally defined writtenVariable!
+    const nameIdShares = (0, linker_1.produceNameSharedIdMap)(ingoing);
+    for (const write of writtenVariable) {
+        for (const link of [...vector.in, ...vector.unknownReferences]) {
+            nextGraph.addEdge(write.nodeId, link.nodeId, graph_1.EdgeType.DefinedBy, 'always', true);
+        }
+        const name = write.name;
+        const readIdsToLink = nameIdShares.get(name);
+        for (const readId of readIdsToLink) {
+            nextGraph.addEdge(readId.nodeId, write.nodeId, graph_1.EdgeType.Reads, 'always', true);
+        }
+        // now, we remove the name from the id shares as they are no longer needed
+        nameIdShares.delete(name);
+        nextGraph.setDefinitionOfVertex(write);
+    }
+    const outgoing = [...variable.out, ...writtenVariable, ...(0, environments_1.makeAllMaybe)(body.out, nextGraph, outEnvironments)];
+    (0, linker_1.linkIngoingVariablesInSameScope)(nextGraph, ingoing);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, nameIdShares, body.out);
+    return {
+        unknownReferences: [],
+        // we only want those not bound by a local variable
+        in: [...variable.in, ...[...nameIdShares.values()].flat()],
+        out: outgoing,
+        graph: nextGraph,
+        environments: outEnvironments,
+        scope: data.activeScope
+    };
+}
+exports.processForLoop = processForLoop;
+//# sourceMappingURL=for-loop.js.map

package/dataflow/internal/process/loops/repeat-loop.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RRepeatLoop } from '../../../../r-bridge';
+export declare function processRepeatLoop<OtherInfo>(loop: RRepeatLoop<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/loops/repeat-loop.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRepeatLoop = void 0;
+const processor_1 = require("../../../processor");
+const linker_1 = require("../../linker");
+function processRepeatLoop(loop, data) {
+    const body = (0, processor_1.processDataflowFor)(loop.body, data);
+    const graph = body.graph;
+    const namedIdShares = (0, linker_1.produceNameSharedIdMap)([...body.in, ...body.unknownReferences]);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(graph, namedIdShares, body.out);
+    return {
+        unknownReferences: [],
+        in: [...body.in, ...body.unknownReferences],
+        out: body.out,
+        environments: body.environments,
+        scope: data.activeScope,
+        graph: body.graph
+    };
+}
+exports.processRepeatLoop = processRepeatLoop;
+//# sourceMappingURL=repeat-loop.js.map

package/dataflow/internal/process/loops/while-loop.d.ts

@@ -0,0 +1,4 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RWhileLoop } from '../../../../r-bridge';
+export declare function processWhileLoop<OtherInfo>(loop: RWhileLoop<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/loops/while-loop.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processWhileLoop = void 0;
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../environments");
+const linker_1 = require("../../linker");
+function processWhileLoop(loop, data) {
+    const condition = (0, processor_1.processDataflowFor)(loop.condition, data);
+    data = { ...data, environments: condition.environments };
+    const body = (0, processor_1.processDataflowFor)(loop.body, data);
+    const environments = condition.environments;
+    const nextGraph = condition.graph.mergeWith(body.graph);
+    const finalEnvironments = (0, environments_1.appendEnvironments)(condition.environments, body.environments);
+    // this is theoretically redundant, but we would have to manually mark all affected edges as maybe this way. This does that for us.
+    const remainingInputs = (0, linker_1.linkInputs)([
+        ...(0, environments_1.makeAllMaybe)(body.unknownReferences, nextGraph, finalEnvironments),
+        ...(0, environments_1.makeAllMaybe)(body.in, nextGraph, finalEnvironments)
+    ], data.activeScope, environments, [...condition.in, ...condition.unknownReferences], nextGraph, true);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, (0, linker_1.produceNameSharedIdMap)(remainingInputs), body.out);
+    return {
+        unknownReferences: [],
+        in: remainingInputs,
+        out: [...(0, environments_1.makeAllMaybe)(body.out, nextGraph, finalEnvironments), ...condition.out],
+        graph: nextGraph,
+        /* the body might not happen if the condition is false */
+        environments: finalEnvironments,
+        scope: data.activeScope
+    };
+}
+exports.processWhileLoop = processWhileLoop;
+//# sourceMappingURL=while-loop.js.map

package/dataflow/internal/process/operators/assignment.d.ts

@@ -0,0 +1,4 @@
+import { ParentInformation, RAssignmentOp } from '../../../../r-bridge';
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+export declare function processAssignment<OtherInfo>(op: RAssignmentOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;