@eagleoutice/flowr 2.0.16 → 2.0.18

package/dataflow/graph/graph.js

@@ -5,6 +5,7 @@ const assert_1 = require("../../util/assert");
 const diff_1 = require("./diff");
 const arrays_1 = require("../../util/arrays");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const environment_1 = require("../environments/environment");
 const clone_1 = require("../environments/clone");
 const built_in_1 = require("../environments/built-in");
@@ -42,8 +43,8 @@ function extractEdgeIds(from, to) {
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
-    // this should be linked separately
-    functionCache = new Map();
+    /* Set of vertices which have sideEffects that we do not know anything about */
+    _unknownSideEffects = new Set();
     constructor(idMap) {
         DataflowGraph.DEFAULT_ENVIRONMENT ??= (0, environment_1.initializeCleanEnvironments)();
         this._idMap = idMap;
@@ -96,16 +97,22 @@ class DataflowGraph {
     get idMap() {
         return this._idMap;
     }
+    /**
+     * Retrieves the set of vertices which have side effects that we do not know anything about.
+     */
+    get unknownSideEffects() {
+        return this._unknownSideEffects;
+    }
     /** Allows setting the id-map explicitly (which should only be used when, e.g., you plan to compare two dataflow graphs on the same AST-basis) */
     setIdMap(idMap) {
         this._idMap = idMap;
     }
     /**
-   * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
-   * @returns the ids of all toplevel vertices in the graph together with their vertex information
+     * @param includeDefinedFunctions - If true this will iterate over function definitions as well and not just the toplevel
+     * @returns the ids of all toplevel vertices in the graph together with their vertex information
      *
      * @see #edges
-   */
+     */
     *vertices(includeDefinedFunctions) {
         if (includeDefinedFunctions) {
             yield* this.vertexInformation.entries();
@@ -143,15 +150,15 @@ class DataflowGraph {
         return this.rootVertices;
     }
     /**
-   * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
-   *
+     * Adds a new vertex to the graph, for ease of use, some arguments are optional and filled automatically.
+     *
      * @param vertex - The vertex to add
      * @param asRoot - If false, this will only add the vertex but do not add it to the {@link rootIds|root vertices} of the graph.
      *                 This is probably only of use, when you construct dataflow graphs for tests.
      *
-   * @see DataflowGraphVertexInfo
-   * @see DataflowGraphVertexArgument
-   */
+     * @see DataflowGraphVertexInfo
+     * @see DataflowGraphVertexArgument
+     */
     addVertex(vertex, asRoot = true) {
         const oldVertex = this.vertexInformation.get(vertex.id);
         if (oldVertex !== undefined) {
@@ -170,11 +177,11 @@ class DataflowGraph {
         return this;
     }
     /**
-   * Will insert a new edge into the graph,
-   * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
-   * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
-    * Please note, that this will never make edges to {@link BuiltIn} as they are not part of the graph.
-   */
+     * Will insert a new edge into the graph,
+     * if the direction of the edge is of no importance (`same-read-read` or `same-def-def`), source
+     * and target will be sorted so that `from` has the lower, and `to` the higher id (default ordering).
+     * Please note that this will never make edges to {@link BuiltIn} as they are not part of the graph.
+     */
     addEdge(from, to, edgeInfo) {
         const { fromId, toId } = extractEdgeIds(from, to);
         const { type, ...rest } = edgeInfo;
@@ -232,6 +239,9 @@ class DataflowGraph {
                 this.rootVertices.add(root);
             }
         }
+        for (const unknown of otherGraph.unknownSideEffects) {
+            this._unknownSideEffects.add(unknown);
+        }
         for (const [id, info] of otherGraph.vertexInformation) {
             const currentInfo = this.vertexInformation.get(id);
             this.vertexInformation.set(id, currentInfo === undefined ? info : mergeNodeInfos(currentInfo, info));
@@ -258,15 +268,6 @@ class DataflowGraph {
             }
         }
     }
-    equals(other, diff = false, names = { left: 'left', right: 'right' }) {
-        const report = (0, diff_1.diffOfDataflowGraphs)({ name: names.left, graph: this }, { name: names.right, graph: other });
-        if (diff) {
-            return report;
-        }
-        else {
-            return report.isEqual();
-        }
-    }
     /**
      * Marks a vertex in the graph to be a definition
      * @param reference - The reference to the vertex to mark as definition
@@ -281,6 +282,32 @@ class DataflowGraph {
             this.vertexInformation.set(reference.nodeId, { ...vertex, tag: 'variable-definition' });
         }
     }
+    /**
+     * Marks a vertex in the graph to be a function call with the new information
+     * @param info - The information about the new function call node
+     */
+    updateToFunctionCall(info) {
+        const vertex = this.getVertex(info.id, true);
+        (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${JSON.stringify(info.id)} to update it to a function call`);
+        (0, assert_1.guard)(vertex.tag === "use" /* VertexType.Use */, () => `node must be a use node for ${JSON.stringify(info.id)} to update it to a function call`);
+        this.vertexInformation.set(info.id, { ...vertex, ...info, tag: "function-call" /* VertexType.FunctionCall */ });
+    }
+    /** If you do not pass the `to` node, this will just mark the node as maybe */
+    addControlDependency(from, to, when) {
+        to = to ? (0, node_id_1.normalizeIdToNumberIfPossible)(to) : undefined;
+        const vertex = this.getVertex(from, true);
+        (0, assert_1.guard)(vertex !== undefined, () => `node must be defined for ${from} to add control dependency`);
+        vertex.controlDependencies ??= [];
+        if (to && vertex.controlDependencies.every(({ id, when: cond }) => id !== to && when !== cond)) {
+            vertex.controlDependencies.push({ id: to, when });
+        }
+        return this;
+    }
+    /** Marks the given node as having unknown side effects */
+    markIdForUnknownSideEffects(id) {
+        this._unknownSideEffects.add((0, node_id_1.normalizeIdToNumberIfPossible)(id));
+        return this;
+    }
 }
 exports.DataflowGraph = DataflowGraph;
 function mergeNodeInfos(current, next) {

package/dataflow/graph/vertex.d.ts

@@ -79,7 +79,7 @@ export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVert
      */
     subflow: DataflowFunctionFlowInformation;
     /**
-     * All exist points of the function definitions.
+     * All exit points of the function definitions.
      * In other words: last expressions/return calls
      */
     exitPoints: readonly NodeId[];
@@ -87,4 +87,9 @@ export interface DataflowGraphVertexFunctionDefinition extends DataflowGraphVert
 }
 export type DataflowGraphVertexArgument = DataflowGraphVertexUse | DataflowGraphVertexVariableDefinition | DataflowGraphVertexFunctionDefinition | DataflowGraphVertexFunctionCall | DataflowGraphValue;
 export type DataflowGraphVertexInfo = Required<DataflowGraphVertexArgument>;
+export declare function isValueVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphValue;
+export declare function isUseVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexUse;
+export declare function isFunctionCallVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexFunctionCall;
+export declare function isVariableDefinitionVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexVariableDefinition;
+export declare function isFunctionDefinitionVertex(vertex: DataflowGraphVertexBase): vertex is DataflowGraphVertexFunctionDefinition;
 export {};

package/dataflow/graph/vertex.js

@@ -1,3 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunctionDefinitionVertex = exports.isVariableDefinitionVertex = exports.isFunctionCallVertex = exports.isUseVertex = exports.isValueVertex = void 0;
+function isValueVertex(vertex) {
+    return vertex.tag === "value" /* VertexType.Value */;
+}
+exports.isValueVertex = isValueVertex;
+function isUseVertex(vertex) {
+    return vertex.tag === "use" /* VertexType.Use */;
+}
+exports.isUseVertex = isUseVertex;
+function isFunctionCallVertex(vertex) {
+    return vertex.tag === "function-call" /* VertexType.FunctionCall */;
+}
+exports.isFunctionCallVertex = isFunctionCallVertex;
+function isVariableDefinitionVertex(vertex) {
+    return vertex.tag === "variable-definition" /* VertexType.VariableDefinition */;
+}
+exports.isVariableDefinitionVertex = isVariableDefinitionVertex;
+function isFunctionDefinitionVertex(vertex) {
+    return vertex.tag === "function-definition" /* VertexType.FunctionDefinition */;
+}
+exports.isFunctionDefinitionVertex = isFunctionDefinitionVertex;
 //# sourceMappingURL=vertex.js.map

package/dataflow/info.d.ts

@@ -57,7 +57,7 @@ export interface DataflowInformation extends DataflowCfgInformation {
     graph: DataflowGraph;
 }
 export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
-export declare function happensInEveryBranch(controlDependencies: ControlDependency[] | undefined): boolean;
+export declare function happensInEveryBranch(controlDependencies: readonly ControlDependency[] | undefined): boolean;
 export declare function alwaysExits(data: DataflowInformation): boolean;
 export declare function filterOutLoopExitPoints(exitPoints: readonly ExitPoint[]): readonly ExitPoint[];
 export declare function diffControlDependency<Report extends WriteableDifferenceReport>(a: ControlDependency | undefined, b: ControlDependency | undefined, info: GenericDifferenceInformation<Report>): void;

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

@@ -4,6 +4,7 @@ import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/
 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 { ForceArguments } from '../common';
 export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     treatIndicesAsString: boolean;
-}): DataflowInformation;
+} & ForceArguments): DataflowInformation;

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

@@ -6,16 +6,41 @@ const known_call_handling_1 = require("../known-call-handling");
 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");
+const built_in_1 = require("../../../../../environments/built-in");
+const built_in_assignment_1 = require("./built-in-assignment");
+function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
+    outInfo.definitionRootNodes.push(rootId);
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+}
 function processAccess(name, args, rootId, data, config) {
     if (args.length < 2) {
         logger_1.dataflowLogger.warn(`Access ${name.content} has less than 2 arguments, skipping`);
-        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data }).information;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs }).information;
     }
     const head = args[0];
     (0, assert_1.guard)(head !== r_function_call_1.EmptyArgument, () => `Access ${name.content} has no source, impossible!`);
     let fnCall;
     if (!config.treatIndicesAsString) {
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data });
+        /* within an access operation which treats its fields, we redefine the table assignment ':=' as a trigger if this is to be treated as a definition */
+        // do we have a local definition that needs to be recovered?
+        const existing = data.environment.current.memory.get(':=');
+        const outInfo = { definitionRootNodes: [] };
+        data.environment.current.memory.set(':=', [{
+                kind: 'built-in-function',
+                definedAt: built_in_1.BuiltIn,
+                controlDependencies: undefined,
+                processor: (name, args, rootId, data) => tableAssignmentProcessor(name, args, rootId, data, outInfo),
+                name: ':=',
+                nodeId: built_in_1.BuiltIn
+            }]);
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
+        /* recover the environment */
+        if (existing !== undefined) {
+            data.environment.current.memory.set(':=', existing);
+        }
+        if (head.value && outInfo.definitionRootNodes.length > 0) {
+            (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { kind: 'variable', name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId);
+        }
     }
     else {
         const newArgs = [...args];
@@ -38,7 +63,7 @@ function processAccess(name, args, rootId, data, config) {
                 };
             }
         }
-        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data });
+        fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs });
     }
     const info = fnCall.information;
     info.graph.addEdge(name.info.id, fnCall.processedArguments[0]?.entryPoint ?? head.info.id, { type: 8 /* EdgeType.Returns */ });
@@ -47,10 +72,7 @@ function processAccess(name, args, rootId, data, config) {
         if (arg !== undefined) {
             info.graph.addEdge(name.info.id, arg.entryPoint, { type: 1 /* EdgeType.Reads */ });
         }
-        if (config.treatIndicesAsString) {
-            // everything but the first is disabled here
-            break;
-        }
+        /* we include the read edges to the constant arguments as well so that they are included if necessary */
     }
     return {
         ...info,

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

@@ -0,0 +1,14 @@
+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';
+import type { MergeableRecord } from '../../../../../../util/objects';
+export interface BuiltInApplyConfiguration extends MergeableRecord {
+    /** the 0-based index of the argument which is the actual function passed, defaults to 1 */
+    readonly indexOfFunction?: number;
+    /** does the argument have a name that it can be given by as well? */
+    readonly nameOfFunctionArgument?: string;
+}
+export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { indexOfFunction, nameOfFunctionArgument }: BuiltInApplyConfiguration): DataflowInformation;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processApply = void 0;
+const known_call_handling_1 = require("../known-call-handling");
+const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const logger_1 = require("../../../../../logger");
+function processApply(name, args, rootId, data, { indexOfFunction = 1, nameOfFunctionArgument }) {
+    /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */
+    const forceArgsMask = new Array(indexOfFunction).fill(false);
+    forceArgsMask.push(true);
+    const { information, processedArguments } = (0, known_call_handling_1.processKnownFunctionCall)({
+        name, args, rootId, data, forceArgs: forceArgsMask
+    });
+    let index = indexOfFunction;
+    /* search, if one of the arguments actually contains the argument name if given in the config */
+    if (nameOfFunctionArgument !== undefined) {
+        const mayFn = args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name && arg.name.content === nameOfFunctionArgument);
+        if (mayFn >= 0) {
+            index = mayFn;
+        }
+    }
+    /* validate, that we indeed have so many arguments to fill this one :D */
+    if (index >= args.length) {
+        logger_1.dataflowLogger.warn(`Function argument at index ${index} not found, skipping`);
+        return information;
+    }
+    const arg = args[index];
+    if (arg === r_function_call_1.EmptyArgument || arg?.value?.type !== "RSymbol" /* RType.Symbol */) {
+        logger_1.dataflowLogger.warn(`Expected symbol as argument at index ${index}, but got ${JSON.stringify(arg)} instead.`);
+        return information;
+    }
+    const functionSymbol = arg.value;
+    const allOtherArguments = processedArguments.filter((_, i) => i !== index).map((arg, i) => {
+        const counterpart = args[i];
+        if (arg && counterpart !== r_function_call_1.EmptyArgument && counterpart.name) {
+            return {
+                name: counterpart.name.content,
+                controlDependencies: data.controlDependencies,
+                nodeId: arg.entryPoint
+            };
+        }
+        else {
+            return r_function_call_1.EmptyArgument;
+        }
+    });
+    const applyCallId = functionSymbol.info.id;
+    /* identify it as a full-blown function call :) */
+    information.graph.updateToFunctionCall({
+        tag: "function-call" /* VertexType.FunctionCall */,
+        id: applyCallId,
+        name: functionSymbol.content,
+        args: allOtherArguments,
+        environment: data.environment,
+        onlyBuiltin: false,
+        controlDependencies: data.controlDependencies
+    });
+    for (const arg of processedArguments) {
+        if (arg) {
+            information.graph.addEdge(applyCallId, arg.entryPoint, { type: 64 /* EdgeType.Argument */ });
+        }
+    }
+    return information;
+}
+exports.processApply = processApply;
+//# sourceMappingURL=built-in-apply.js.map

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

@@ -5,7 +5,11 @@ import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model'
 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 interface AssignmentConfiguration {
+import type { IdentifierDefinition } from '../../../../../environments/identifier';
+import type { ForceArguments } from '../common';
+import type { REnvironmentInformation } from '../../../../../environments/environment';
+import type { DataflowGraph } from '../../../../../graph/graph';
+export interface AssignmentConfiguration extends ForceArguments {
     readonly superAssignment?: boolean;
     readonly swapSourceAndTarget?: boolean;
     readonly makeMaybe?: boolean;
@@ -19,7 +23,7 @@ export interface AssignmentConfiguration {
  */
 export declare function processAssignment<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: AssignmentConfiguration): DataflowInformation;
 export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfiguration {
-    readonly name: RSymbol<OtherInfo & ParentInformation>;
+    readonly nameOfAssignmentFunction: string;
     readonly source: RNode<OtherInfo & ParentInformation>;
     readonly args: [DataflowInformation, DataflowInformation];
     readonly target: RSymbol<OtherInfo & ParentInformation>;
@@ -27,3 +31,16 @@ export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfi
     readonly data: DataflowProcessorInformation<OtherInfo>;
     readonly information: DataflowInformation;
 }
+/**
+ * Consider a call like `x <- v`
+ * @param information        - the information to define the assignment within
+ * @param nodeToDefine       - `x`
+ * @param sourceIds          - `v`
+ * @param rootIdOfAssignment - `<-`
+ * @param quoteSource        - whether to quote the source (i.e., define `x` without a direct reference to `v`)
+ * @param superAssignment    - whether this is a super assignment (i.e., `<<-`)
+ */
+export declare function markAsAssignment(information: {
+    environment: REnvironmentInformation;
+    graph: DataflowGraph;
+}, nodeToDefine: IdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, quoteSource?: boolean, superAssignment?: boolean): void;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processAssignment = void 0;
+exports.markAsAssignment = 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");
@@ -15,7 +15,7 @@ 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 */
+        /* they are all mapped to `<-` in R, but we mark super as well */
         content: `${prefix}${superAssignment ? '<<-' : '<-'}`,
         lexeme: target.lexeme,
         location: target.location,
@@ -35,16 +35,16 @@ function processAssignment(name,
 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;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs }).information;
     }
     const effectiveArgs = getEffectiveOrder(config, args);
     const { target, source } = extractSourceAndTarget(effectiveArgs, name);
     const { type, named } = target;
     if (type === "RSymbol" /* RType.Symbol */) {
-        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget });
+        const res = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, reverseOrder: !config.swapSourceAndTarget, forceArgs: config.forceArgs });
         return processAssignmentToSymbol({
             ...config,
-            name,
+            nameOfAssignmentFunction: name.content,
             source,
             target,
             args: getEffectiveOrder(config, res.processedArguments),
@@ -68,7 +68,7 @@ args, rootId, data, config) {
         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;
+    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: effectiveArgs, rootId, data, forceArgs: config.forceArgs }).information;
 }
 exports.processAssignment = processAssignment;
 function extractSourceAndTarget(args, name) {
@@ -105,11 +105,12 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
         args: mappedArgs,
         rootId,
         data,
-        reverseOrder: !config.swapSourceAndTarget
+        reverseOrder: !config.swapSourceAndTarget,
+        forceArgs: config.forceArgs
     });
     return processAssignmentToSymbol({
         ...config,
-        name,
+        nameOfAssignmentFunction: name.content,
         source,
         target: symbol,
         args: getEffectiveOrder(config, res.processedArguments),
@@ -121,10 +122,38 @@ function processAssignmentToString(target, args, name, rootId, data, config, sou
 function checkFunctionDef(source, sourceInfo) {
     return sourceInfo.graph.getVertex(source.info.id)?.tag === "function-definition" /* VertexType.FunctionDefinition */;
 }
+/**
+ * Consider a call like `x <- v`
+ * @param information        - the information to define the assignment within
+ * @param nodeToDefine       - `x`
+ * @param sourceIds          - `v`
+ * @param rootIdOfAssignment - `<-`
+ * @param quoteSource        - whether to quote the source (i.e., define `x` without a direct reference to `v`)
+ * @param superAssignment    - whether this is a super assignment (i.e., `<<-`)
+ */
+function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, quoteSource, superAssignment) {
+    information.environment = (0, define_1.define)(nodeToDefine, superAssignment, information.environment);
+    information.graph.setDefinitionOfVertex(nodeToDefine);
+    if (!quoteSource) {
+        for (const sourceId of sourceIds) {
+            information.graph.addEdge(nodeToDefine, sourceId, { type: 2 /* EdgeType.DefinedBy */ });
+        }
+    }
+    information.graph.addEdge(nodeToDefine, rootIdOfAssignment, { 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(nodeToDefine.nodeId);
+    for (const [id, edge] of (out ?? [])) {
+        edge.types &= ~1 /* EdgeType.Reads */;
+        if (edge.types == 0) {
+            out?.delete(id);
+        }
+    }
+}
+exports.markAsAssignment = markAsAssignment;
 /**
  * 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 }) {
+function processAssignmentToSymbol({ nameOfAssignmentFunction, 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 */) {
@@ -132,25 +161,12 @@ function processAssignmentToSymbol({ name, source, args: [targetArg, sourceArg],
     }
     // we drop the first arg which we use to pass along arguments :D
     const readFromSourceWritten = sourceArg.out.slice(1);
-    const readTargets = [{ nodeId: rootId, name: name.content, controlDependencies: data.controlDependencies }, ...sourceArg.unknownReferences, ...sourceArg.in, ...targetArg.in.filter(i => i.nodeId !== target.info.id), ...readFromSourceWritten];
+    const readTargets = [{ nodeId: rootId, name: nameOfAssignmentFunction, 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);
-            }
-        }
+        markAsAssignment(information, write, [source.info.id], rootId, quoteSource, superAssignment);
     }
     information.graph.addEdge(rootId, targetArg.entryPoint, { type: 8 /* EdgeType.Returns */ });
     if (quoteSource) {

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

@@ -63,7 +63,7 @@ function processForLoop(name, args, rootId, data) {
             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
+            // now, we remove the name from the id shares as they are no longer necessary
             nameIdShares.delete(name);
             nextGraph.setDefinitionOfVertex(write);
         }

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

@@ -45,8 +45,17 @@ function processFunctionDefinition(name, args, rootId, data) {
     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 */);
+    // functions can be called multiple times,
+    // so if they have a global effect, we have to link them as if they would be executed a loop
+    /* theoretically, we should just check if there is a global effect-write somewhere within */
+    if (remainingRead.length > 0) {
+        const nameIdShares = (0, linker_1.produceNameSharedIdMap)(remainingRead);
+        const definedInLocalEnvironment = new Set([...bodyEnvironment.current.memory.values()].flat().map(d => d.nodeId));
+        // Everything that is in body.out but not within the local environment populated for the function scope is a potential escape ~> global definition
+        const globalBodyOut = body.out.filter(d => !definedInLocalEnvironment.has(d.nodeId));
+        (0, linker_1.linkCircularRedefinitionsWithinALoop)(body.graph, nameIdShares, globalBodyOut);
+    }
     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) {

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

@@ -33,23 +33,23 @@ function processIfThenElse(name, args, rootId, data) {
     // 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') {
+    if (conditionIsFalse !== 0 /* Ternary.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') {
+        if (conditionIsTrue !== 0 /* Ternary.Always */) {
             makeThenMaybe = true;
         }
     }
     let otherwise;
     let makeOtherwiseMaybe = false;
-    if (otherwiseArg !== undefined && conditionIsTrue !== 'always') {
+    if (otherwiseArg !== undefined && conditionIsTrue !== 0 /* Ternary.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') {
+        if (conditionIsFalse !== 0 /* Ternary.Always */) {
             makeOtherwiseMaybe = true;
         }
     }

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

@@ -6,14 +6,15 @@ 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) {
+    /* we do not really know what loading the library does and what side effects it causes, hence we mark it as an unknown side effect */
     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;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).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;
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, hasUnknownSideEffect: true }).information;
     }
     // treat as a function call but convert the first argument to a string
     const newArg = {
@@ -26,7 +27,10 @@ function processLibrary(name, args, rootId, data) {
             str: nameToLoad.content
         }
     };
-    return (0, known_call_handling_1.processKnownFunctionCall)({ name, args: (0, make_argument_1.wrapArgumentsUnnamed)([newArg], data.completeAst.idMap), rootId, data }).information;
+    return (0, known_call_handling_1.processKnownFunctionCall)({
+        name, args: (0, make_argument_1.wrapArgumentsUnnamed)([newArg], data.completeAst.idMap), rootId, data,
+        hasUnknownSideEffect: true
+    }).information;
 }
 exports.processLibrary = processLibrary;
 //# sourceMappingURL=built-in-library.js.map

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

@@ -4,6 +4,7 @@ import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/
 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?: {
+import type { ForceArguments } from '../common';
+export declare function processQuote<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     quoteArgumentsWithIndex?: number;
-}): DataflowInformation;
+} & ForceArguments): DataflowInformation;

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

@@ -3,7 +3,7 @@ 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 { information, processedArguments, fnRef } = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: config.forceArgs });
     const inRefs = [fnRef];
     const outRefs = [];
     const unknownRefs = [];