@eagleoutice/flowr 1.3.11 → 1.3.13

package/dataflow/v1/internal/linker.js

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

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

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

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

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

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