@eagleoutice/flowr 1.5.2 → 2.0.1

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

@@ -1,105 +0,0 @@
-"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");
-const source_1 = require("./source");
-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);
-    }
-    let info = {
-        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
-    };
-    // parse a source call and analyze the referenced code
-    if ((0, source_1.isSourceCall)(functionCallName, data.activeScope, finalEnv)) {
-        info = (0, source_1.processSourceCall)(functionCall, data, info);
-    }
-    return info;
-}
-exports.processFunctionCall = processFunctionCall;
-//# sourceMappingURL=function-call.js.map

package/dataflow/internal/process/functions/function-definition.d.ts

@@ -1,4 +0,0 @@
-import type { DataflowInformation } from '../../info';
-import type { DataflowProcessorInformation } from '../../../processor';
-import type { 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

@@ -1,176 +0,0 @@
-"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/source.d.ts

@@ -1,8 +0,0 @@
-import type { IdGenerator, NoInfo, RParseRequest, RParseRequestProvider, ParentInformation, RFunctionCall } from '../../../../r-bridge';
-import { type DataflowProcessorInformation } from '../../../processor';
-import { type DataflowScopeName, type Identifier, type REnvironmentInformation } from '../../../environments';
-import type { DataflowInformation } from '../../info';
-export declare function setSourceProvider(provider: RParseRequestProvider): void;
-export declare function isSourceCall(name: Identifier, scope: DataflowScopeName, environments: REnvironmentInformation): boolean;
-export declare function processSourceCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation): DataflowInformation;
-export declare function sourceRequest<OtherInfo>(request: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation, getId: IdGenerator<NoInfo>): DataflowInformation;

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

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sourceRequest = exports.processSourceCall = exports.isSourceCall = exports.setSourceProvider = void 0;
-const r_bridge_1 = require("../../../../r-bridge");
-const shell_executor_1 = require("../../../../r-bridge/shell-executor");
-const core_1 = require("../../../../core");
-const processor_1 = require("../../../processor");
-const environments_1 = require("../../../environments");
-const index_1 = require("../../../index");
-const config_1 = require("../../../../config");
-let sourceProvider = (0, r_bridge_1.requestProviderFromFile)();
-function setSourceProvider(provider) {
-    sourceProvider = provider;
-}
-exports.setSourceProvider = setSourceProvider;
-function isSourceCall(name, scope, environments) {
-    const definitions = (0, environments_1.resolveByName)(name, scope, environments);
-    if (definitions === undefined) {
-        return false;
-    }
-    // fail if there are multiple definitions because then we must treat the complete import as a maybe because it might do something different
-    if (definitions.length !== 1) {
-        return false;
-    }
-    const def = definitions[0];
-    return def.name == 'source' && def.kind == 'built-in-function';
-}
-exports.isSourceCall = isSourceCall;
-function processSourceCall(functionCall, data, information) {
-    const sourceFile = functionCall.arguments[0];
-    if ((0, config_1.getConfig)().ignoreSourceCalls) {
-        index_1.dataflowLogger.info(`Skipping source call ${JSON.stringify(sourceFile)} (disabled in config file)`);
-        return information;
-    }
-    if (sourceFile?.value?.type == "RString" /* RType.String */) {
-        const path = (0, r_bridge_1.removeRQuotes)(sourceFile.lexeme);
-        const request = sourceProvider.createRequest(path);
-        // check if the sourced file has already been dataflow analyzed, and if so, skip it
-        if (data.referenceChain.includes((0, r_bridge_1.requestFingerprint)(request))) {
-            index_1.dataflowLogger.info(`Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
-            return information;
-        }
-        return sourceRequest(request, data, information, (0, r_bridge_1.sourcedDeterministicCountingIdGenerator)(path, functionCall.location));
-    }
-    else {
-        index_1.dataflowLogger.info(`Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
-        return information;
-    }
-}
-exports.processSourceCall = processSourceCall;
-function sourceRequest(request, data, information, getId) {
-    const executor = new shell_executor_1.RShellExecutor();
-    // parse, normalize and dataflow the sourced file
-    let normalized;
-    let dataflow;
-    try {
-        const parsed = (0, core_1.executeSingleSubStep)('parse', request, executor);
-        normalized = (0, core_1.executeSingleSubStep)('normalize', parsed, undefined, getId);
-        dataflow = (0, processor_1.processDataflowFor)(normalized.ast, {
-            ...data,
-            currentRequest: request,
-            environments: information.environments,
-            referenceChain: [...data.referenceChain, (0, r_bridge_1.requestFingerprint)(request)]
-        });
-    }
-    catch (e) {
-        index_1.dataflowLogger.warn(`Failed to analyze sourced file ${JSON.stringify(request)}, skipping: ${e.message}`);
-        return information;
-    }
-    // update our graph with the sourced file's information
-    const newInformation = { ...information };
-    newInformation.environments = (0, environments_1.overwriteEnvironments)(information.environments, dataflow.environments);
-    newInformation.graph.mergeWith(dataflow.graph);
-    // this can be improved, see issue #628
-    for (const [k, v] of normalized.idMap) {
-        data.completeAst.idMap.set(k, v);
-    }
-    return newInformation;
-}
-exports.sourceRequest = sourceRequest;
-//# sourceMappingURL=source.js.map

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

@@ -1,4 +0,0 @@
-import type { DataflowInformation } from '../info';
-import type { DataflowProcessorInformation } from '../../processor';
-import type { 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

@@ -1,56 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-import type { DataflowInformation } from '../../info';
-import type { DataflowProcessorInformation } from '../../../processor';
-import type { 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

@@ -1,54 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-import type { DataflowInformation } from '../../info';
-import type { DataflowProcessorInformation } from '../../../processor';
-import type { 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

@@ -1,21 +0,0 @@
-"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

@@ -1,4 +0,0 @@
-import type { DataflowInformation } from '../../info';
-import type { DataflowProcessorInformation } from '../../../processor';
-import type { 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

@@ -1,31 +0,0 @@
-"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

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