@eagleoutice/flowr 1.3.11

package/dataflow/internal/linker.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkCircularRedefinitionsWithinALoop = exports.linkInputs = exports.getAllLinkedFunctionDefinitions = exports.linkFunctionCalls = exports.linkArgumentsOnCall = exports.linkReadVariablesInSameScopeWithNames = exports.produceNameSharedIdMap = exports.linkIngoingVariablesInSameScope = void 0;
+const environments_1 = require("../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("../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/internal/process/access.d.ts

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

package/dataflow/internal/process/access.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAccess = void 0;
+const processor_1 = require("../../processor");
+const environments_1 = require("../../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;
+    const 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;
+            }
+            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);
+            (0, environments_1.overwriteEnvironments)(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/internal/process/expression-list.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Processes a list of expressions joining their dataflow graphs accordingly.
+ * @module
+ */
+import { DataflowInformation } from '../info';
+import { ParentInformation, RExpressionList } from '../../../r-bridge';
+import { DataflowProcessorInformation } from '../../processor';
+export declare function processExpressionList<OtherInfo>(exprList: RExpressionList<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -0,0 +1,148 @@
+"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("../../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 teh 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.initializeCleanInfo)(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 => {
+                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);
+        environments = (0, environments_1.overwriteEnvironments)(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/internal/process/functions/argument.d.ts

@@ -0,0 +1,8 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RArgument, RNode } from '../../../../r-bridge';
+import { DataflowGraph } from '../../../graph';
+import { IdentifierReference } from '../../../environments';
+export declare const UnnamedArgumentPrefix = "unnamed-argument-";
+export declare function linkReadsForArgument<OtherInfo>(root: RNode<OtherInfo & ParentInformation>, ingoingRefs: IdentifierReference[], graph: DataflowGraph): void;
+export declare function processFunctionArgument<OtherInfo>(argument: RArgument<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionArgument = exports.linkReadsForArgument = exports.UnnamedArgumentPrefix = void 0;
+const processor_1 = require("../../../processor");
+const r_bridge_1 = require("../../../../r-bridge");
+const graph_1 = require("../../../graph");
+const scopes_1 = require("../../../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/internal/process/functions/exit-points.d.ts

@@ -0,0 +1,2 @@
+import { NodeId, ParentInformation, RFunctionDefinition } from '../../../../r-bridge';
+export declare function retrieveExitPointsOfFunctionDefinition<OtherInfo>(functionDefinition: RFunctionDefinition<OtherInfo & ParentInformation>): NodeId[];

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveExitPointsOfFunctionDefinition = void 0;
+const assert_1 = require("../../../../util/assert");
+function retrieveExitPointsOfFunctionDefinition(functionDefinition) {
+    const exitPoints = visitExitPoints(functionDefinition.body);
+    return exitPoints.knownIds.concat(exitPoints.potentialIds);
+}
+exports.retrieveExitPointsOfFunctionDefinition = retrieveExitPointsOfFunctionDefinition;
+function visitExitPoints(node) {
+    const type = node.type;
+    switch (type) {
+        case "RExpressionList" /* RType.ExpressionList */:
+            return visitExpressionList(node);
+        case "RFunctionCall" /* RType.FunctionCall */:
+            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 */:
+            return { knownIds: [], potentialIds: [] };
+        default:
+            (0, assert_1.assertUnreachable)(type);
+    }
+    return {
+        knownIds: [],
+        potentialIds: [node.info.id]
+    };
+}
+// we use keepSelfAsPotential in order to track nodes like 2 + 3, which keep themselves as potential exit points if there are no knownIds
+function knownIdsOfChildren(keepSelfAsPotential, ...children) {
+    const knownIds = children.flatMap(child => visitExitPoints(child).knownIds);
+    return {
+        knownIds,
+        potentialIds: knownIds.length === 0 ? [keepSelfAsPotential] : []
+    };
+}
+function visitLoops(loop) {
+    const result = visitExitPoints(loop.body);
+    // conditions may contain return statements which we have to keep
+    let otherKnownIds = [];
+    if (loop.type === "RForLoop" /* RType.ForLoop */) {
+        otherKnownIds = visitExitPoints(loop.variable).knownIds;
+        otherKnownIds.push(...visitExitPoints(loop.vector).knownIds);
+    }
+    else if (loop.type === "RWhileLoop" /* RType.WhileLoop */) {
+        otherKnownIds = visitExitPoints(loop.condition).knownIds;
+    }
+    return {
+        knownIds: [...result.knownIds, ...otherKnownIds],
+        potentialIds: []
+    };
+}
+function visitExpressionList(node) {
+    const known = [];
+    let lastPotentialIds = [];
+    // we only keep the potential ids of the last expression, which is no comment
+    for (const child of node.children) {
+        const { knownIds, potentialIds } = visitExitPoints(child);
+        known.push(...knownIds);
+        if (child.type !== "RComment" /* RType.Comment */) {
+            lastPotentialIds = potentialIds;
+        }
+    }
+    return {
+        knownIds: known,
+        potentialIds: lastPotentialIds
+    };
+}
+function visitIf(node) {
+    // conditions can contain return statements
+    const known = visitExitPoints(node.condition).knownIds;
+    const potential = [];
+    const thenCase = visitExitPoints(node.then);
+    known.push(...thenCase.knownIds);
+    potential.push(...thenCase.potentialIds);
+    if (node.otherwise !== undefined) {
+        const otherwiseCase = visitExitPoints(node.otherwise);
+        known.push(...otherwiseCase.knownIds);
+        potential.push(...otherwiseCase.potentialIds);
+    }
+    return {
+        knownIds: known,
+        potentialIds: potential
+    };
+}
+//# sourceMappingURL=exit-points.js.map

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

@@ -0,0 +1,5 @@
+import { DataflowInformation } from '../../info';
+import { DataflowProcessorInformation } from '../../../processor';
+import { ParentInformation, RFunctionCall } from '../../../../r-bridge';
+export declare const UnnamedFunctionCallPrefix = "unnamed-function-call-";
+export declare function processFunctionCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;