@eagleoutice/flowr 1.5.2 → 2.0.1

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processGet = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const make_argument_1 = require("../argument/make-argument");
+const logger_1 = require("../../../../../logger");
+const retriever_1 = require("../../../../../../r-bridge/retriever");
+function processGet(name, args, rootId, data) {
+    if (args.length !== 1) {
+        logger_1.dataflowLogger.warn(`symbol access with ${name.content} has not 1 argument, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const retrieve = (0, unpack_argument_1.unpackArgument)(args[0]);
+    if (retrieve === undefined || retrieve.type !== "RString" /* RType.String */) {
+        logger_1.dataflowLogger.warn(`symbol access with ${name.content} has not 1 argument, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const treatTargetAsSymbol = {
+        type: "RSymbol" /* RType.Symbol */,
+        info: retrieve.info,
+        content: (0, retriever_1.removeRQuotes)(retrieve.lexeme),
+        lexeme: retrieve.lexeme,
+        location: retrieve.location,
+        namespace: undefined
+    };
+    const { information } = (0, known_call_handling_1.processKnownFunctionCall)({
+        name,
+        args: (0, make_argument_1.wrapArgumentsUnnamed)([treatTargetAsSymbol], data.completeAst.idMap),
+        rootId,
+        data
+    });
+    return information;
+}
+exports.processGet = processGet;
+//# sourceMappingURL=built-in-get.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-if-then-else.d.ts

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+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';
+export declare function processIfThenElse<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-if-then-else.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processIfThenElse = void 0;
+const processor_1 = require("../../../../../processor");
+const info_1 = require("../../../../../info");
+const known_call_handling_1 = require("../known-call-handling");
+const common_1 = require("../common");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const logger_1 = require("../../../../../logger");
+const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
+const append_1 = require("../../../../../environments/append");
+const environment_1 = require("../../../../../environments/environment");
+function processIfThenElse(name, args, rootId, data) {
+    if (args.length !== 2 && args.length !== 3) {
+        logger_1.dataflowLogger.warn(`If-then-else ${name.content} has something different from 2 or 3 arguments, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const [condArg, thenArg, otherwiseArg] = args.map(unpack_argument_1.unpackArgument);
+    if (condArg === undefined || thenArg === undefined) {
+        logger_1.dataflowLogger.warn(`If-then-else ${name.content} has empty condition or then case in ${JSON.stringify(args)}, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const cond = (0, processor_1.processDataflowFor)(condArg, data);
+    if ((0, info_1.alwaysExits)(cond)) {
+        logger_1.dataflowLogger.warn(`If-then-else ${rootId} forces exit in condition, skipping rest`);
+        return cond;
+    }
+    const originalDependency = data.controlDependencies;
+    // currently we update the cd afterward :sweat:
+    data = { ...data, environment: cond.environment };
+    let then;
+    let makeThenMaybe = false;
+    // we should defer this to the abstract interpretation
+    const conditionIsFalse = (0, resolve_by_name_1.resolvesToBuiltInConstant)(condArg?.lexeme, data.environment, false);
+    const conditionIsTrue = (0, resolve_by_name_1.resolvesToBuiltInConstant)(condArg?.lexeme, data.environment, true);
+    if (conditionIsFalse !== 'always') {
+        then = (0, processor_1.processDataflowFor)(thenArg, data);
+        if (then.entryPoint) {
+            then.graph.addEdge(name.info.id, then.entryPoint, { type: 8 /* EdgeType.Returns */ });
+        }
+        if (conditionIsTrue !== 'always') {
+            makeThenMaybe = true;
+        }
+    }
+    let otherwise;
+    let makeOtherwiseMaybe = false;
+    if (otherwiseArg !== undefined && conditionIsTrue !== 'always') {
+        otherwise = (0, processor_1.processDataflowFor)(otherwiseArg, data);
+        if (otherwise.entryPoint) {
+            otherwise.graph.addEdge(name.info.id, otherwise.entryPoint, { type: 8 /* EdgeType.Returns */ });
+        }
+        if (conditionIsFalse !== 'always') {
+            makeOtherwiseMaybe = true;
+        }
+    }
+    const nextGraph = cond.graph.mergeWith(then?.graph).mergeWith(otherwise?.graph);
+    const thenEnvironment = then?.environment ?? cond.environment;
+    // if there is no "else" case, we have to recover whatever we had before as it may be not executed
+    const finalEnvironment = (0, append_1.appendEnvironment)(thenEnvironment, otherwise ? otherwise.environment : cond.environment);
+    // again within an if-then-else we consider all actives to be read
+    const ingoing = [
+        ...cond.in,
+        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.in, nextGraph, finalEnvironment, false, rootId) : then?.in ?? []),
+        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.in, nextGraph, finalEnvironment, false, rootId) : otherwise?.in ?? []),
+        ...cond.unknownReferences,
+        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.unknownReferences, nextGraph, finalEnvironment, false, rootId) : then?.unknownReferences ?? []),
+        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.unknownReferences, nextGraph, finalEnvironment, false, rootId) : otherwise?.unknownReferences ?? []),
+    ];
+    // we assign all with a maybe marker
+    // we do not merge even if they appear in both branches because the maybe links will refer to different ids
+    const outgoing = [
+        ...cond.out,
+        ...(makeThenMaybe ? (0, environment_1.makeAllMaybe)(then?.out, nextGraph, finalEnvironment, true, rootId) : then?.out ?? []),
+        ...(makeOtherwiseMaybe ? (0, environment_1.makeAllMaybe)(otherwise?.out, nextGraph, finalEnvironment, true, rootId) : otherwise?.out ?? []),
+    ];
+    (0, common_1.patchFunctionCall)({
+        nextGraph,
+        rootId,
+        name,
+        data: { ...data, controlDependencies: originalDependency },
+        argumentProcessResult: [cond, then, otherwise]
+    });
+    // as an if always evaluates its condition, we add a 'reads'-edge
+    nextGraph.addEdge(name.info.id, cond.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    const exitPoints = [
+        ...(then?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeThenMaybe ? [...data.controlDependencies ?? []] : e.controlDependencies })),
+        ...(otherwise?.exitPoints ?? []).map(e => ({ ...e, controlDependencies: makeOtherwiseMaybe ? [...data.controlDependencies ?? []] : e.controlDependencies }))
+    ];
+    return {
+        unknownReferences: [],
+        in: [{ nodeId: rootId, name: name.content, controlDependencies: originalDependency }, ...ingoing],
+        out: outgoing,
+        exitPoints,
+        entryPoint: rootId,
+        environment: finalEnvironment,
+        graph: nextGraph
+    };
+}
+exports.processIfThenElse = processIfThenElse;
+//# sourceMappingURL=built-in-if-then-else.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-library.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 processLibrary<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-library.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLibrary = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+const logger_1 = require("../../../../../logger");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const make_argument_1 = require("../argument/make-argument");
+function processLibrary(name, args, rootId, data) {
+    if (args.length !== 1) {
+        logger_1.dataflowLogger.warn(`Currently only one-arg library-likes are allows (for ${name.content}), skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const nameToLoad = (0, unpack_argument_1.unpackArgument)(args[0]);
+    if (nameToLoad === undefined || nameToLoad.type !== "RSymbol" /* RType.Symbol */) {
+        logger_1.dataflowLogger.warn('No library name provided, skipping');
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    // treat as a function call but convert the first argument to a string
+    const newArg = {
+        type: "RString" /* RType.String */,
+        info: nameToLoad.info,
+        lexeme: nameToLoad.lexeme,
+        location: nameToLoad.location,
+        content: {
+            quotes: 'none',
+            str: nameToLoad.content
+        }
+    };
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: (0, make_argument_1.wrapArgumentsUnnamed)([newArg], data.completeAst.idMap), rootId, data }).information;
+}
+exports.processLibrary = processLibrary;
+//# sourceMappingURL=built-in-library.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-logical-bin-op.d.ts

@@ -0,0 +1,9 @@
+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 processSpecialBinOp<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+    lazy: boolean;
+}): DataflowInformation;

package/dataflow/internal/process/functions/call/built-in/built-in-logical-bin-op.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processSpecialBinOp = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+const logger_1 = require("../../../../../logger");
+function processSpecialBinOp(name, args, rootId, data, config) {
+    if (!config.lazy) {
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    else if (args.length != 2) {
+        logger_1.dataflowLogger.warn(`Logical bin-op ${name.content} has something else than 2 arguments, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data,
+        patchData: (d, i) => {
+            if (i === 1) {
+                // the rhs will be overshadowed by the lhs
+                return { ...d, controlDependencies: [...d.controlDependencies ?? [], name.info.id] };
+            }
+            return d;
+        }
+    });
+    for (const arg of processedArguments) {
+        if (arg) {
+            information.graph.addEdge(name.info.id, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
+        }
+        // only do first if lazy
+        if (config.lazy) {
+            break;
+        }
+    }
+    return information;
+}
+exports.processSpecialBinOp = processSpecialBinOp;
+//# sourceMappingURL=built-in-logical-bin-op.js.map

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

@@ -0,0 +1,7 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+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 { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+export declare function processPipe<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-pipe.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPipe = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+const assert_1 = require("../../../../../../util/assert");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const logger_1 = require("../../../../../logger");
+function processPipe(name, args, rootId, data) {
+    const { information } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    if (args.length !== 2) {
+        logger_1.dataflowLogger.warn(`Pipe ${name.content} has something else than 2 arguments, skipping`);
+        return information;
+    }
+    const [lhs, rhs] = args.map(unpack_argument_1.unpackArgument);
+    (0, assert_1.guard)(lhs !== undefined && rhs !== undefined, () => `lhs and rhs must be present, but ${JSON.stringify(lhs)} and ${JSON.stringify(rhs)} were found instead.`);
+    if (rhs.type !== "RFunctionCall" /* RType.FunctionCall */) {
+        logger_1.dataflowLogger.warn(`Expected rhs of pipe to be a function call, but got ${rhs.type} instead.`);
+    }
+    else {
+        const functionCallNode = information.graph.getVertex(rhs.info.id, true);
+        (0, assert_1.guard)(functionCallNode?.tag === "function-call" /* VertexType.FunctionCall */, () => `Expected function call node with id ${rhs.info.id} to be a function call node, but got ${functionCallNode?.tag} instead.`);
+        // make the lhs an argument node:
+        const argId = lhs.info.id;
+        logger_1.dataflowLogger.trace(`Linking pipe arg ${argId} as first argument of ${rhs.info.id}`);
+        functionCallNode.args.unshift({
+            name: undefined,
+            nodeId: argId,
+            controlDependencies: data.controlDependencies
+        });
+        information.graph.addEdge(functionCallNode.id, argId, { type: 64 /* EdgeType.Argument */ });
+    }
+    return information;
+}
+exports.processPipe = processPipe;
+//# sourceMappingURL=built-in-pipe.js.map

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

@@ -0,0 +1,9 @@
+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 processQuote<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config?: {
+    quoteArgumentsWithIndex?: number;
+}): DataflowInformation;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processQuote = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+function processQuote(name, args, rootId, data, config) {
+    const { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+    const inRefs = [fnRef];
+    const outRefs = [];
+    const unknownRefs = [];
+    for (let i = 0; i < args.length; i++) {
+        const processedArg = processedArguments[i];
+        if (processedArg && i !== config?.quoteArgumentsWithIndex) {
+            inRefs.push(...processedArg.in);
+            outRefs.push(...processedArg.out);
+            unknownRefs.push(...processedArg.unknownReferences);
+        }
+        else if (processedArg) {
+            information.graph.addEdge(rootId, processedArg.entryPoint, { type: 256 /* EdgeType.NonStandardEvaluation */ });
+        }
+    }
+    return {
+        ...information,
+        in: inRefs,
+        out: outRefs,
+        unknownReferences: unknownRefs
+    };
+}
+exports.processQuote = processQuote;
+//# sourceMappingURL=built-in-quote.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-repeat-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 { 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 processRepeatLoop<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-repeat-loop.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRepeatLoop = void 0;
+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 unpack_argument_1 = require("../argument/unpack-argument");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+function processRepeatLoop(name, args, rootId, data) {
+    if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument) {
+        logger_1.dataflowLogger.warn(`Repeat-Loop ${name.content} does not have 1 argument, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const unpacked = (0, unpack_argument_1.unpackArgument)(args[0]);
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
+        name,
+        args: unpacked ? [unpacked] : args,
+        rootId,
+        data,
+        markAsNSE: [0]
+    });
+    const body = processedArguments[0];
+    (0, assert_1.guard)(body !== undefined, () => `Repeat-Loop ${name.content} has no body, impossible!`);
+    const namedIdShares = (0, linker_1.produceNameSharedIdMap)([...body.in, ...body.unknownReferences]);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, namedIdShares, body.out);
+    information.exitPoints = (0, info_1.filterOutLoopExitPoints)(information.exitPoints);
+    return information;
+}
+exports.processRepeatLoop = processRepeatLoop;
+//# sourceMappingURL=built-in-repeat-loop.js.map

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

@@ -0,0 +1,12 @@
+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 processReplacementFunction<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, 
+/** last one has to be the value */
+args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
+    makeMaybe?: boolean;
+    assignmentOperator?: '<-' | '<<-';
+}): DataflowInformation;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processReplacementFunction = void 0;
+const info_1 = require("../../../../../info");
+const known_call_handling_1 = require("../known-call-handling");
+const log_1 = require("../../../../../../util/log");
+const built_in_assignment_1 = require("./built-in-assignment");
+const common_1 = require("../common");
+const assert_1 = require("../../../../../../util/assert");
+const logger_1 = require("../../../../../logger");
+const graph_1 = require("../../../../../graph/graph");
+const dfg_1 = require("../../../../../../util/mermaid/dfg");
+function processReplacementFunction(name, 
+/** last one has to be the value */
+args, rootId, data, config) {
+    if (args.length < 2) {
+        logger_1.dataflowLogger.warn(`Replacement ${name.content} has less than 2 arguments, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    /* we only get here if <-, <<-, ... or whatever is part of the replacement is not overwritten */
+    (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Replacement ${name.content} with ${JSON.stringify(args)}, processing`);
+    /* we assign the first argument by the last for now and maybe mark as maybe!, we can keep the symbol as we now know we have an assignment */
+    const res = (0, built_in_assignment_1.processAssignment)(name, [args[0], args[args.length - 1]], rootId, data, { superAssignment: config.assignmentOperator === '<<-', makeMaybe: config.makeMaybe });
+    /* now, we soft-inject other arguments, so that calls like `x[y] <- 3` are linked correctly */
+    const { callArgs } = (0, common_1.processAllArguments)({
+        functionName: (0, info_1.initializeCleanDataflowInformation)(rootId, data),
+        args: args.slice(1, -1),
+        data,
+        functionRootId: rootId,
+        finalGraph: res.graph,
+    });
+    const fn = res.graph.getVertex(rootId, true);
+    (0, assert_1.guard)(fn?.tag === "function-call" /* VertexType.FunctionCall */ && fn.args.length === 2, () => `Function ${rootId} not found in graph or not 2-arg fn-call (${JSON.stringify(fn)}) ${(0, dfg_1.graphToMermaidUrl)(res.graph)}`);
+    fn.args = [fn.args[0], ...callArgs, fn.args[1]];
+    /* a replacement reads all of its call args as well, at least as far as I am aware of */
+    for (const arg of callArgs) {
+        const ref = (0, graph_1.getReferenceOfArgument)(arg);
+        if (ref !== undefined) {
+            res.graph.addEdge(rootId, ref, { type: 1 /* EdgeType.Reads */ });
+        }
+    }
+    return res;
+}
+exports.processReplacementFunction = processReplacementFunction;
+//# sourceMappingURL=built-in-replacement.js.map

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

@@ -0,0 +1,11 @@
+import { type DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { RParseRequest, RParseRequestProvider } from '../../../../../../r-bridge/retriever';
+import type { IdGenerator, 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';
+import type { NoInfo } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+export declare function setSourceProvider(provider: RParseRequestProvider): void;
+export declare function processSourceCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+export declare function sourceRequest<OtherInfo>(request: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation, getId: IdGenerator<NoInfo>): DataflowInformation;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceRequest = exports.processSourceCall = exports.setSourceProvider = void 0;
+const shell_executor_1 = require("../../../../../../r-bridge/shell-executor");
+const processor_1 = require("../../../../../processor");
+const config_1 = require("../../../../../../config");
+const parser_1 = require("../../../../../../r-bridge/lang-4.x/ast/parser/json/parser");
+const known_call_handling_1 = require("../known-call-handling");
+const retriever_1 = require("../../../../../../r-bridge/retriever");
+const decorate_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+const overwrite_1 = require("../../../../../environments/overwrite");
+let sourceProvider = (0, retriever_1.requestProviderFromFile)();
+function setSourceProvider(provider) {
+    sourceProvider = provider;
+}
+exports.setSourceProvider = setSourceProvider;
+function processSourceCall(name, args, rootId, data) {
+    const information = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    const sourceFile = args[0];
+    if ((0, config_1.getConfig)().ignoreSourceCalls) {
+        logger_1.dataflowLogger.info(`Skipping source call ${JSON.stringify(sourceFile)} (disabled in config file)`);
+        return information;
+    }
+    if (sourceFile !== r_function_call_1.EmptyArgument && sourceFile?.value?.type == "RString" /* RType.String */) {
+        const path = (0, retriever_1.removeRQuotes)(sourceFile.lexeme);
+        const request = sourceProvider.createRequest(path);
+        // check if the sourced file has already been dataflow analyzed, and if so, skip it
+        if (data.referenceChain.includes((0, retriever_1.requestFingerprint)(request))) {
+            logger_1.dataflowLogger.info(`Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+            return information;
+        }
+        return sourceRequest(request, data, information, (0, decorate_1.sourcedDeterministicCountingIdGenerator)(path, name.location));
+    }
+    else {
+        logger_1.dataflowLogger.info(`Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
+        return information;
+    }
+}
+exports.processSourceCall = processSourceCall;
+function sourceRequest(request, data, information, getId) {
+    const executor = new shell_executor_1.RShellExecutor();
+    // parse, normalize and dataflow the sourced file
+    let normalized;
+    let dataflow;
+    try {
+        const parsed = (0, retriever_1.retrieveParseDataFromRCode)(request, executor);
+        normalized = (0, parser_1.normalize)(parsed, getId);
+        dataflow = (0, processor_1.processDataflowFor)(normalized.ast, {
+            ...data,
+            currentRequest: request,
+            environment: information.environment,
+            referenceChain: [...data.referenceChain, (0, retriever_1.requestFingerprint)(request)]
+        });
+    }
+    catch (e) {
+        logger_1.dataflowLogger.warn(`Failed to analyze sourced file ${JSON.stringify(request)}, skipping: ${e.message}`);
+        return information;
+    }
+    // update our graph with the sourced file's information
+    const newInformation = { ...information };
+    newInformation.environment = (0, overwrite_1.overwriteEnvironment)(information.environment, dataflow.environment);
+    newInformation.graph.mergeWith(dataflow.graph);
+    // this can be improved, see issue #628
+    for (const [k, v] of normalized.idMap) {
+        data.completeAst.idMap.set(k, v);
+    }
+    return newInformation;
+}
+exports.sourceRequest = sourceRequest;
+//# sourceMappingURL=built-in-source.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-while-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 { 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 processWhileLoop<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-while-loop.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processWhileLoop = void 0;
+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 unpack_argument_1 = require("../argument/unpack-argument");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+const environment_1 = require("../../../../../environments/environment");
+function processWhileLoop(name, args, rootId, data) {
+    if (args.length !== 2 || args[1] === r_function_call_1.EmptyArgument) {
+        logger_1.dataflowLogger.warn(`While-Loop ${name.content} does not have 2 arguments, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    const unpackedArgs = args.map(unpack_argument_1.unpackArgument);
+    if (unpackedArgs.some(assert_1.isUndefined)) {
+        logger_1.dataflowLogger.warn(`While-Loop ${name.content} has empty arguments in ${JSON.stringify(args)}, skipping`);
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+    }
+    /* we inject the cf-dependency of the while-loop after the condition */
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
+        name,
+        args: unpackedArgs,
+        rootId,
+        data,
+        markAsNSE: [1],
+        patchData: (d, i) => {
+            if (i === 1) {
+                return { ...d, controlDependencies: [...d.controlDependencies ?? [], name.info.id] };
+            }
+            return d;
+        }
+    });
+    const [condition, body] = processedArguments;
+    (0, assert_1.guard)(condition !== undefined && body !== undefined, () => `While-Loop ${name.content} has no condition or body, impossible!`);
+    const originalDependency = data.controlDependencies;
+    if ((0, info_1.alwaysExits)(condition)) {
+        logger_1.dataflowLogger.warn(`While-Loop ${rootId} forces exit in condition, skipping rest`);
+        return condition;
+    }
+    const remainingInputs = (0, linker_1.linkInputs)([
+        ...(0, environment_1.makeAllMaybe)(body.unknownReferences, information.graph, information.environment, false),
+        ...(0, environment_1.makeAllMaybe)(body.in, information.graph, information.environment, false)
+    ], information.environment, [...condition.in, ...condition.unknownReferences], information.graph, true);
+    (0, linker_1.linkCircularRedefinitionsWithinALoop)(information.graph, (0, linker_1.produceNameSharedIdMap)(remainingInputs), body.out);
+    // as the while-loop always evaluates its condition
+    information.graph.addEdge(name.info.id, condition.entryPoint, { type: 1 /* EdgeType.Reads */ });
+    return {
+        unknownReferences: [],
+        in: [{ nodeId: name.info.id, name: name.lexeme, controlDependencies: originalDependency }, ...remainingInputs],
+        out: [...(0, environment_1.makeAllMaybe)(body.out, information.graph, information.environment, true), ...condition.out],
+        entryPoint: name.info.id,
+        exitPoints: (0, info_1.filterOutLoopExitPoints)(body.exitPoints),
+        graph: information.graph,
+        environment: information.environment
+    };
+}
+exports.processWhileLoop = processWhileLoop;
+//# sourceMappingURL=built-in-while-loop.js.map

package/dataflow/internal/process/functions/call/common.d.ts

@@ -0,0 +1,35 @@
+import type { DataflowInformation } from '../../../../info';
+import type { DataflowProcessorInformation } from '../../../../processor';
+import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
+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 { DataflowGraph, FunctionArgument } from '../../../../graph/graph';
+import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { REnvironmentInformation } from '../../../../environments/environment';
+import type { IdentifierReference } from '../../../../environments/identifier';
+import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+export interface ProcessAllArgumentInput<OtherInfo> {
+    readonly functionName: DataflowInformation;
+    readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
+    readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    readonly finalGraph: DataflowGraph;
+    readonly functionRootId: NodeId;
+    readonly patchData?: (data: DataflowProcessorInformation<OtherInfo & ParentInformation>, i: number) => DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    /** which arguments are to be marked as {@link EdgeType#NonStandardEvaluation|non-standard-evaluation}? */
+    readonly markAsNSE?: readonly number[];
+}
+export interface ProcessAllArgumentResult {
+    readonly finalEnv: REnvironmentInformation;
+    readonly callArgs: FunctionArgument[];
+    readonly remainingReadInArgs: IdentifierReference[];
+    readonly processedArguments: (DataflowInformation | undefined)[];
+}
+export declare function processAllArguments<OtherInfo>({ functionName, args, data, finalGraph, functionRootId, patchData }: ProcessAllArgumentInput<OtherInfo>): ProcessAllArgumentResult;
+export interface PatchFunctionCallInput<OtherInfo> {
+    readonly nextGraph: DataflowGraph;
+    readonly rootId: NodeId;
+    readonly name: RSymbol<OtherInfo & ParentInformation>;
+    readonly data: DataflowProcessorInformation<OtherInfo & ParentInformation>;
+    readonly argumentProcessResult: readonly (DataflowInformation | undefined)[];
+}
+export declare function patchFunctionCall<OtherInfo>({ nextGraph, rootId, name, data, argumentProcessResult }: PatchFunctionCallInput<OtherInfo>): void;