@eagleoutice/flowr 1.5.2 → 2.0.1

package/dataflow/internal/process/functions/call/built-in/built-in-assignment.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAssignment = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+const assert_1 = require("../../../../../../util/assert");
+const log_1 = require("../../../../../../util/log");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const process_named_call_1 = require("../../../process-named-call");
+const make_argument_1 = require("../argument/make-argument");
+const logger_1 = require("../../../../../logger");
+const overwrite_1 = require("../../../../../environments/overwrite");
+const retriever_1 = require("../../../../../../r-bridge/retriever");
+const define_1 = require("../../../../../environments/define");
+function toReplacementSymbol(target, prefix, superAssignment) {
+    return {
+        type: "RSymbol" /* RType.Symbol */,
+        info: target.info,
+        /* they are all mapped to <- in R, but we mark super as well */
+        content: `${prefix}${superAssignment ? '<<-' : '<-'}`,
+        lexeme: target.lexeme,
+        location: target.location,
+        namespace: undefined
+    };
+}
+function getEffectiveOrder(config, args) {
+    return config.swapSourceAndTarget ? [args[1], args[0]] : args;
+}
+/**
+ * Processes an assignment, i.e., `<target> <- <source>`.
+ * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.
+ * This includes handling of replacement functions (e.g., `names(x) <- ...` as \`names&lt;-\` `(x, ...)`).
+ */
+function processAssignment(name, 
+/* we expect them to be ordered in the sense that we have (source, target): `<source> <- <target>` */
+args, rootId, data, config) {
+    if (args.length != 2) {
+        logger_1.dataflowLogger.warn(`Assignment ${name.content} has something else than 2 arguments, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const effectiveArgs = getEffectiveOrder(config, args);
+    const { target, source } = extractSourceAndTarget(effectiveArgs, name);
+    const { type, flavor } = target;
+    if (type === "RSymbol" /* RType.Symbol */) {
+        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget });
+        return processAssignmentToSymbol({
+            ...config,
+            name,
+            source,
+            target,
+            args: getEffectiveOrder(config, res.processedArguments),
+            rootId,
+            data,
+            information: res.information,
+        });
+    }
+    else if (config.canBeReplacement && type === "RFunctionCall" /* RType.FunctionCall */ && flavor === 'named') {
+        /* as replacement functions take precedence over the lhs fn-call (i.e., `names(x) <- ...` is independent from the definition of `names`), we do not have to process the call */
+        logger_1.dataflowLogger.debug(`Assignment ${name.content} has a function call as target => replacement function ${target.lexeme}`);
+        const replacement = toReplacementSymbol(target, target.functionName.content, config.superAssignment ?? false);
+        return (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [...target.arguments, source]);
+    }
+    else if (config.canBeReplacement && type === "RAccess" /* RType.Access */) {
+        logger_1.dataflowLogger.debug(`Assignment ${name.content} has an access as target => replacement function ${target.lexeme}`);
+        const replacement = toReplacementSymbol(target, target.operator, config.superAssignment ?? false);
+        return (0, process_named_call_1.processAsNamedCall)(replacement, data, replacement.content, [(0, make_argument_1.toUnnamedArgument)(target.accessed, data.completeAst.idMap), ...target.access, source]);
+    }
+    else if (type === "RString" /* RType.String */) {
+        return processAssignmentToString(target, args, name, rootId, data, config, source);
+    }
+    logger_1.dataflowLogger.warn(`Assignment ${name.content} has an unknown target type ${target.type}, skipping`);
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: effectiveArgs, rootId, data }).information;
+}
+exports.processAssignment = processAssignment;
+function extractSourceAndTarget(args, name) {
+    const source = (0, unpack_argument_1.unpackArgument)(args[1]);
+    const target = (0, unpack_argument_1.unpackArgument)(args[0]);
+    (0, assert_1.guard)(source !== undefined, () => `Assignment ${name.content} has no source, impossible!`);
+    (0, assert_1.guard)(target !== undefined, () => `Assignment ${name.content} has no target, impossible!`);
+    return { source, target };
+}
+function produceWrittenNodes(rootId, target, isFunctionDef, data, makeMaybe) {
+    return target.in.map(ref => ({
+        ...ref,
+        kind: isFunctionDef ? 'function' : 'variable',
+        definedAt: rootId,
+        controlDependencies: data.controlDependencies ?? (makeMaybe ? [] : undefined)
+    }));
+}
+function processAssignmentToString(target, args, name, rootId, data, config, source) {
+    const symbol = {
+        type: "RSymbol" /* RType.Symbol */,
+        info: target.info,
+        content: (0, retriever_1.removeRQuotes)(target.lexeme),
+        lexeme: target.lexeme,
+        location: target.location,
+        namespace: undefined
+    };
+    // treat first argument to Symbol
+    const mappedArgs = config.swapSourceAndTarget ? [args[0], {
+            ...args[1],
+            value: symbol
+        }] : [{ ...args[0], value: symbol }, args[1]];
+    const res = (0, known_call_handling_1.processKnownFunctionCall)({
+        name,
+        args: mappedArgs,
+        rootId,
+        data,
+        reverseOrder: !config.swapSourceAndTarget
+    });
+    return processAssignmentToSymbol({
+        ...config,
+        name,
+        source,
+        target: symbol,
+        args: getEffectiveOrder(config, res.processedArguments),
+        rootId,
+        data,
+        information: res.information
+    });
+}
+function checkFunctionDef(source, sourceInfo) {
+    return sourceInfo.graph.getVertex(source.info.id)?.tag === "function-definition" /* VertexType.FunctionDefinition */;
+}
+/**
+ * Helper function whenever it is known that the _target_ of an assignment is a (single) symbol (i.e. `x <- ...`, but not `names(x) <- ...`).
+ */
+function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg], target, rootId, data, information, superAssignment, makeMaybe, quoteSource }) {
+    const isFunctionDef = checkFunctionDef(source, sourceArg);
+    const writeNodes = produceWrittenNodes(rootId, targetArg, isFunctionDef, data, makeMaybe ?? false);
+    if (writeNodes.length !== 1 && log_1.log.settings.minLevel <= 4 /* LogLevel.Warn */) {
+        log_1.log.warn(`Unexpected write number in assignment: ${JSON.stringify(writeNodes)}`);
+    }
+    // we drop the first arg which we use to pass along arguments :D
+    const readFromSourceWritten = sourceArg.out.slice(1);
+    const readTargets = [{ nodeId: name.info.id, name: name.content, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
+    const writeTargets = [...writeNodes, ...writeNodes, ...readFromSourceWritten];
+    information.environment = (0, overwrite_1.overwriteEnvironment)(targetArg.environment, sourceArg.environment);
+    // install assigned variables in environment
+    for (const write of writeNodes) {
+        information.environment = (0, define_1.define)(write, superAssignment, information.environment);
+        information.graph.setDefinitionOfVertex(write);
+        if (!quoteSource) {
+            information.graph.addEdge(write, source.info.id, { type: 2 /* EdgeType.DefinedBy */ });
+        }
+        information.graph.addEdge(write, rootId, { type: 2 /* EdgeType.DefinedBy */ });
+        // kinda dirty, but we have to remove existing read edges for the symbol, added by the child
+        const out = information.graph.outgoingEdges(write.nodeId);
+        for (const [id, edge] of (out ?? [])) {
+            edge.types &= ~1 /* EdgeType.Reads */;
+            if (edge.types == 0) {
+                out?.delete(id);
+            }
+        }
+    }
+    information.graph.addEdge(name.info.id, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
+    if (quoteSource) {
+        information.graph.addEdge(rootId, source.info.id, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+    }
+    return {
+        ...information,
+        unknownReferences: [],
+        entryPoint: name.info.id,
+        in: readTargets,
+        out: writeTargets
+    };
+}
+//# sourceMappingURL=built-in-assignment.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-expression-list.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Processes a list of expressions joining their dataflow graphs accordingly.
+ * @module
+ */
+import type { DataflowInformation } from '../../../../../info';
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+export declare function processExpressionList<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-expression-list.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processExpressionList = void 0;
+const info_1 = require("../../../../../info");
+const processor_1 = require("../../../../../processor");
+const linker_1 = require("../../../../linker");
+const assert_1 = require("../../../../../../util/assert");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const common_1 = require("../common");
+const environment_1 = require("../../../../../environments/environment");
+const graph_1 = require("../../../../../graph/graph");
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const scoping_1 = require("../../../../../environments/scoping");
+const built_in_1 = require("../../../../../environments/built-in");
+const overwrite_1 = require("../../../../../environments/overwrite");
+const logger_1 = require("../../../../../logger");
+const dotDotDotAccess = /\.\.\d+/;
+function linkReadNameToWriteIfPossible(read, environments, listEnvironments, remainingRead, nextGraph) {
+    const readName = read.name && dotDotDotAccess.test(read.name) ? '...' : read.name;
+    const probableTarget = readName ? (0, resolve_by_name_1.resolveByName)(readName, environments) : undefined;
+    // 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 the 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, { type: 1 /* EdgeType.Reads */ });
+    }
+}
+function processNextExpression(currentElement, environment, listEnvironments, remainingRead, nextGraph) {
+    // all inputs that have not been written until now, are read!
+    for (const read of [...currentElement.in, ...currentElement.unknownReferences]) {
+        linkReadNameToWriteIfPossible(read, environment, listEnvironments, remainingRead, nextGraph);
+    }
+}
+function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, 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 > inputEnvironment.level) {
+                environment = (0, scoping_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.definedAt !== built_in_1.BuiltIn) {
+                            nextGraph.addEdge(def.nodeId, functionCall, { type: 128 /* EdgeType.SideEffectOnCall */ });
+                        }
+                    }
+                }
+                current = current.parent;
+            }
+            // we update all definitions to be linked with the corresponding function call
+            inputEnvironment = (0, overwrite_1.overwriteEnvironment)(inputEnvironment, environment);
+        }
+    }
+    return inputEnvironment;
+}
+function processExpressionList(name, args, rootId, data) {
+    const expressions = args.map(unpack_argument_1.unpackArgument);
+    logger_1.dataflowLogger.trace(`processing expression list with ${expressions.length} expressions`);
+    let environment = data.environment;
+    // 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(data.completeAst.idMap);
+    const out = [];
+    const exitPoints = [];
+    let expressionCounter = 0;
+    const processedExpressions = [];
+    let defaultReturnExpr = undefined;
+    for (const expression of expressions) {
+        logger_1.dataflowLogger.trace(`processing expression ${++expressionCounter} of ${expressions.length}`);
+        if (expression === undefined) {
+            processedExpressions.push(undefined);
+            continue;
+        }
+        // use the current environments for processing
+        data = { ...data, environment: environment };
+        const processed = (0, processor_1.processDataflowFor)(expression, data);
+        processedExpressions.push(processed);
+        nextGraph.mergeWith(processed.graph);
+        defaultReturnExpr = processed;
+        // 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
+        if (exitPoints.length > 0) {
+            processed.out = (0, environment_1.makeAllMaybe)(processed.out, nextGraph, processed.environment, true);
+            processed.in = (0, environment_1.makeAllMaybe)(processed.in, nextGraph, processed.environment, false);
+            processed.unknownReferences = (0, environment_1.makeAllMaybe)(processed.unknownReferences, nextGraph, processed.environment, false);
+        }
+        (0, info_1.addNonDefaultExitPoints)(exitPoints, processed.exitPoints);
+        out.push(...processed.out);
+        logger_1.dataflowLogger.trace(`expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
+        processNextExpression(processed, environment, listEnvironments, remainingRead, nextGraph);
+        const calledEnvs = (0, linker_1.linkFunctionCalls)(nextGraph, data.completeAst.idMap, processed.graph);
+        environment = exitPoints.length > 0 ? (0, overwrite_1.overwriteEnvironment)(environment, processed.environment) : processed.environment;
+        // if the called function has global redefinitions, we have to keep them within our environment
+        environment = updateSideEffectsForCalledFunctions(calledEnvs, environment, nextGraph);
+        for (const { nodeId } of processed.out) {
+            listEnvironments.add(nodeId);
+        }
+        /** if at least built-one of the exit points encountered happens unconditionally, we exit here (dead code)! */
+        if ((0, info_1.alwaysExits)(processed)) {
+            /* if there is an always-exit expression, there is no default return active anymore */
+            defaultReturnExpr = undefined;
+            break;
+        }
+    }
+    logger_1.dataflowLogger.trace(`expression list exits with ${remainingRead.size} remaining read names`);
+    if (defaultReturnExpr) {
+        exitPoints.push({
+            type: 0 /* ExitPointType.Default */,
+            nodeId: defaultReturnExpr.entryPoint,
+            controlDependencies: data.controlDependencies
+        });
+    }
+    const ingoing = [...remainingRead.values()].flat();
+    const rootNode = data.completeAst.idMap.get(rootId);
+    const withGroup = rootNode?.grouping;
+    if (withGroup) {
+        ingoing.push({ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies });
+        (0, common_1.patchFunctionCall)({
+            nextGraph,
+            rootId,
+            name,
+            data,
+            argumentProcessResult: processedExpressions
+        });
+        // process all exit points as potential returns:
+        for (const exit of exitPoints) {
+            if (exit.type === 1 /* ExitPointType.Return */ || exit.type === 0 /* ExitPointType.Default */) {
+                nextGraph.addEdge(rootId, exit.nodeId, { type: 8 /* EdgeType.Returns */ });
+            }
+        }
+    }
+    const meId = withGroup ? rootId : (processedExpressions.find(assert_1.isNotUndefined)?.entryPoint ?? rootId);
+    return {
+        /* no active nodes remain, they are consumed within the remaining read collection */
+        unknownReferences: [],
+        in: ingoing,
+        out,
+        environment: environment,
+        graph: nextGraph,
+        /* if we have no group we take the last evaluated expr */
+        entryPoint: meId,
+        exitPoints: withGroup ? [{ nodeId: rootId, type: 0 /* ExitPointType.Default */, controlDependencies: data.controlDependencies }]
+            : exitPoints
+    };
+}
+exports.processExpressionList = processExpressionList;
+//# sourceMappingURL=built-in-expression-list.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-for-loop.d.ts

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+export declare function processForLoop<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-for-loop.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processForLoop = void 0;
+const processor_1 = require("../../../../../processor");
+const info_1 = require("../../../../../info");
+const linker_1 = require("../../../../linker");
+const known_call_handling_1 = require("../known-call-handling");
+const assert_1 = require("../../../../../../util/assert");
+const common_1 = require("../common");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const logger_1 = require("../../../../../logger");
+const overwrite_1 = require("../../../../../environments/overwrite");
+const define_1 = require("../../../../../environments/define");
+const append_1 = require("../../../../../environments/append");
+const environment_1 = require("../../../../../environments/environment");
+const scoping_1 = require("../../../../../environments/scoping");
+function processForLoop(name, args, rootId, data) {
+    if (args.length !== 3) {
+        logger_1.dataflowLogger.warn(`For-Loop ${name.content} does not have three arguments, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const [variableArg, vectorArg, bodyArg] = args.map(unpack_argument_1.unpackArgument);
+    (0, assert_1.guard)(variableArg !== undefined && vectorArg !== undefined && bodyArg !== undefined, () => `For-Loop ${JSON.stringify(args)} has missing arguments! Bad!`);
+    const vector = (0, processor_1.processDataflowFor)(vectorArg, data);
+    if ((0, info_1.alwaysExits)(vector)) {
+        logger_1.dataflowLogger.warn(`For-Loop ${rootId} forces exit in vector, skipping rest`);
+        return vector;
+    }
+    const variable = (0, processor_1.processDataflowFor)(variableArg, data);
+    // this should not be able to exit always!
+    const originalDependency = data.controlDependencies;
+    data = { ...data, controlDependencies: [...data.controlDependencies ?? [], name.info.id] };
+    let headEnvironments = (0, overwrite_1.overwriteEnvironment)(vector.environment, variable.environment);
+    const headGraph = variable.graph.mergeWith(vector.graph);
+    const writtenVariable = [...variable.unknownReferences, ...variable.in];
+    for (const write of writtenVariable) {
+        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, kind: 'variable' }, false, headEnvironments);
+    }
+    data = { ...data, environment: headEnvironments };
+    /* process the body without any environment first, to retrieve all open references */
+    let environment = (0, environment_1.initializeCleanEnvironments)();
+    while (headEnvironments.level > environment.level) {
+        environment = (0, scoping_1.pushLocalEnvironment)(environment);
+    }
+    const body = (0, processor_1.processDataflowFor)(bodyArg, { ...data, environment });
+    const nextGraph = headGraph.mergeWith(body.graph);
+    const outEnvironment = (0, append_1.appendEnvironment)(headEnvironments, body.environment);
+    // 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, environment_1.makeAllMaybe)(body.in, nextGraph, outEnvironment, false),
+        ...vector.unknownReferences,
+        ...(0, environment_1.makeAllMaybe)(body.unknownReferences, nextGraph, outEnvironment, false)
+    ];
+    // 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) {
+        nextGraph.addEdge(write.nodeId, vector.entryPoint, { type: 2 /* EdgeType.DefinedBy */ });
+        const name = write.name;
+        if (name) {
+            const readIdsToLink = nameIdShares.get(name);
+            for (const readId of readIdsToLink) {
+                nextGraph.addEdge(readId.nodeId, write.nodeId, { type: 1 /* EdgeType.Reads */ });
+            }
+            // 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, environment_1.makeAllMaybe)(body.out, nextGraph, outEnvironment, true)];
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, nameIdShares, body.out);
+    (0, common_1.patchFunctionCall)({
+        nextGraph,
+        rootId,
+        name,
+        data: { ...data, controlDependencies: originalDependency },
+        argumentProcessResult: [variable, vector, body]
+    });
+    /* mark the last argument as nse */
+    nextGraph.addEdge(rootId, body.entryPoint, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+    // as the for-loop always evaluates its variable and condition
+    nextGraph.addEdge(name.info.id, variable.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    nextGraph.addEdge(name.info.id, vector.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    return {
+        unknownReferences: [],
+        // we only want those not bound by a local variable
+        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency }, ...variable.in, ...[...nameIdShares.values()].flat()],
+        out: outgoing,
+        graph: nextGraph,
+        entryPoint: name.info.id,
+        exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
+        environment: outEnvironment
+    };
+}
+exports.processForLoop = processForLoop;
+//# sourceMappingURL=built-in-for-loop.js.map

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

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-function-definition.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFunctionDefinition = void 0;
+const processor_1 = require("../../../../../processor");
+const linker_1 = require("../../../../linker");
+const known_call_handling_1 = require("../known-call-handling");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const assert_1 = require("../../../../../../util/assert");
+const logger_1 = require("../../../../../logger");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const graph_1 = require("../../../../../graph/graph");
+const overwrite_1 = require("../../../../../environments/overwrite");
+const scoping_1 = require("../../../../../environments/scoping");
+const environment_1 = require("../../../../../environments/environment");
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+function processFunctionDefinition(name, args, rootId, data) {
+    if (args.length < 1) {
+        logger_1.dataflowLogger.warn(`Function Definition ${name.content} does not have an argument, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    /* we remove the last argument, as it is the body */
+    const parameters = args.slice(0, -1);
+    const bodyArg = (0, unpack_argument_1.unpackArgument)(args[args.length - 1]);
+    (0, assert_1.guard)(bodyArg !== undefined, () => `Function Definition ${JSON.stringify(args)} has missing body! Bad!`);
+    const originalEnvironment = data.environment;
+    // 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 graph_1.DataflowGraph(data.completeAst.idMap);
+    let readInParameters = [];
+    for (const param of parameters) {
+        (0, assert_1.guard)(param !== r_function_call_1.EmptyArgument, () => `Empty argument in function definition ${name.content}, ${JSON.stringify(args)}`);
+        const processed = (0, processor_1.processDataflowFor)(param, data);
+        subgraph.mergeWith(processed.graph);
+        const read = [...processed.in, ...processed.unknownReferences];
+        (0, linker_1.linkInputs)(read, data.environment, readInParameters, subgraph, false);
+        data = { ...data, environment: (0, overwrite_1.overwriteEnvironment)(data.environment, processed.environment) };
+    }
+    const paramsEnvironments = data.environment;
+    const body = (0, processor_1.processDataflowFor)(bodyArg, data);
+    // As we know, parameters cannot technically duplicate (i.e., their names are unique), we overwrite their environments.
+    // This is the correct behavior, even if someone uses non-`=` arguments in functions.
+    const bodyEnvironment = body.environment;
+    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, paramsEnvironments, readInParameters.slice(), body.graph, true /* functions do not have to be called */);
+    subgraph.mergeWith(body.graph);
+    logger_1.dataflowLogger.trace(`Function definition with id ${name.info.id} has ${remainingRead.length} remaining reads`);
+    const outEnvironment = (0, overwrite_1.overwriteEnvironment)(paramsEnvironments, bodyEnvironment);
+    for (const read of remainingRead) {
+        if (read.name) {
+            subgraph.addVertex({
+                tag: "use" /* VertexType.Use */,
+                id: read.nodeId,
+                environment: undefined,
+                controlDependencies: []
+            });
+        }
+    }
+    const flow = {
+        unknownReferences: [],
+        in: remainingRead,
+        out: [],
+        entryPoint: body.entryPoint,
+        graph: new Set(subgraph.rootIds()),
+        environment: outEnvironment
+    };
+    const exitPoints = body.exitPoints;
+    updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, name);
+    const graph = new graph_1.DataflowGraph(data.completeAst.idMap).mergeWith(subgraph, false);
+    graph.addVertex({
+        tag: "function-definition" /* VertexType.FunctionDefinition */,
+        id: name.info.id,
+        environment: (0, scoping_1.popLocalEnvironment)(outEnvironment),
+        controlDependencies: data.controlDependencies,
+        subflow: flow,
+        exitPoints: exitPoints?.filter(e => e.type === 1 /* ExitPointType.Return */ || e.type === 0 /* ExitPointType.Default */).map(e => e.nodeId) ?? []
+    });
+    return {
+        /* 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 } */
+        unknownReferences: [],
+        in: [],
+        out: [],
+        exitPoints: [],
+        entryPoint: name.info.id,
+        graph,
+        environment: originalEnvironment
+    };
+}
+exports.processFunctionDefinition = processFunctionDefinition;
+function updateNestedFunctionClosures(exitPoints, subgraph, outEnvironment, name) {
+    // track *all* function definitions - including 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" /* VertexType.FunctionDefinition */) {
+            continue;
+        }
+        const ingoingRefs = info.subflow.in;
+        const remainingIn = new Set();
+        for (const ingoing of ingoingRefs) {
+            for (const { nodeId } of exitPoints) {
+                const node = subgraph.getVertex(nodeId, true);
+                const env = (0, environment_1.initializeCleanEnvironments)();
+                env.current.memory = node === undefined ? outEnvironment.current.memory : (node.environment?.current.memory ?? outEnvironment.current.memory);
+                const resolved = ingoing.name ? (0, resolve_by_name_1.resolveByName)(ingoing.name, env) : undefined;
+                if (resolved === undefined) {
+                    remainingIn.add(ingoing);
+                    continue;
+                }
+                logger_1.dataflowLogger.trace(`Found ${resolved.length} references to open ref ${id} in closure of function definition ${name.info.id}`);
+                for (const ref of resolved) {
+                    subgraph.addEdge(ingoing, ref, { type: 1 /* EdgeType.Reads */ });
+                }
+            }
+        }
+        logger_1.dataflowLogger.trace(`Keeping ${remainingIn.size} (unique) references to open ref ${id} in closure of function definition ${name.info.id}`);
+        info.subflow.in = [...remainingIn];
+    }
+}
+function prepareFunctionEnvironment(data) {
+    let env = (0, environment_1.initializeCleanEnvironments)();
+    for (let i = 0; i < data.environment.level + 1 /* add another env */; i++) {
+        env = (0, scoping_1.pushLocalEnvironment)(env);
+    }
+    return { ...data, environment: 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 is `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 = read.name ? (0, resolve_by_name_1.resolveByName)(read.name, parameterEnvs) : undefined;
+        if (resolved !== undefined) {
+            for (const ref of resolved) {
+                parameters.addEdge(read, ref, { type: 1 /* EdgeType.Reads */ });
+            }
+            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) => String(a.nodeId) < String(b.nodeId) ? 1 : -1);
+        if (writingOuts.length === 0) {
+            remainingRead.push(read);
+            continue;
+        }
+        if (writingOuts[0].controlDependencies === undefined) {
+            parameters.addEdge(read, writingOuts[0], { type: 1 /* EdgeType.Reads */ });
+            continue;
+        }
+        for (const out of writingOuts) {
+            parameters.addEdge(read, out, { type: 1 /* EdgeType.Reads */ });
+        }
+    }
+    return remainingRead;
+}
+//# sourceMappingURL=built-in-function-definition.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-get.d.ts

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function processGet<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;