@eagleoutice/flowr 2.6.2 → 2.7.0

package/dataflow/graph/unknown-replacement.d.ts

@@ -8,10 +8,12 @@ export type ReplacementOperatorHandlerArgs = {
 };
 export type ReplacementOperatorHandler = (args: ReplacementOperatorHandlerArgs) => void;
 /**
- *
+ * Register a new (global) handler for replacement operators.
+ * @see {@link handleReplacementOperator}
  */
 export declare function onReplacementOperator(handler: ReplacementOperatorHandler): void;
 /**
- *
+ * Handle a replacement operator by calling all registered handlers.
+ * @see {@link onReplacementOperator}
  */
 export declare function handleReplacementOperator(args: ReplacementOperatorHandlerArgs): void;

package/dataflow/graph/unknown-replacement.js

@@ -4,13 +4,15 @@ exports.onReplacementOperator = onReplacementOperator;
 exports.handleReplacementOperator = handleReplacementOperator;
 const handlers = [];
 /**
- *
+ * Register a new (global) handler for replacement operators.
+ * @see {@link handleReplacementOperator}
  */
 function onReplacementOperator(handler) {
     handlers.push(handler);
 }
 /**
- *
+ * Handle a replacement operator by calling all registered handlers.
+ * @see {@link onReplacementOperator}
  */
 function handleReplacementOperator(args) {
     handlers.forEach(handler => handler(args));

package/dataflow/graph/vertex.d.ts

@@ -7,9 +7,9 @@ import type { BuiltInMappingName } from '../environments/built-in';
 export declare enum VertexType {
     Value = "value",
     Use = "use",
-    FunctionCall = "function-call",
-    VariableDefinition = "variable-definition",
-    FunctionDefinition = "function-definition"
+    FunctionCall = "fcall",
+    VariableDefinition = "vdef",
+    FunctionDefinition = "fdef"
 }
 export declare const ValidVertexTypes: Set<string>;
 export declare const ValidVertexTypeReverse: {

package/dataflow/graph/vertex.js

@@ -14,9 +14,9 @@ var VertexType;
 (function (VertexType) {
     VertexType["Value"] = "value";
     VertexType["Use"] = "use";
-    VertexType["FunctionCall"] = "function-call";
-    VertexType["VariableDefinition"] = "variable-definition";
-    VertexType["FunctionDefinition"] = "function-definition";
+    VertexType["FunctionCall"] = "fcall";
+    VertexType["VariableDefinition"] = "vdef";
+    VertexType["FunctionDefinition"] = "fdef";
 })(VertexType || (exports.VertexType = VertexType = {}));
 exports.ValidVertexTypes = new Set(Object.values(VertexType));
 exports.ValidVertexTypeReverse = Object.fromEntries(Object.entries(VertexType).map(([k, v]) => [v, k]));

package/dataflow/info.d.ts

@@ -102,12 +102,19 @@ export interface DataflowInformation extends DataflowCfgInformation {
  * This is to be used as a "starting point" when processing leaf nodes during the dataflow extraction.
  * @see {@link DataflowInformation}
  */
-export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'builtInEnvironment' | 'completeAst'>): DataflowInformation;
+export declare function initializeCleanDataflowInformation<T>(entryPoint: NodeId, data: Pick<DataflowProcessorInformation<T>, 'environment' | 'completeAst'>): DataflowInformation;
 /**
  * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
  * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranchSet} - for the set-based version
  */
 export declare function happensInEveryBranch(controlDependencies: readonly ControlDependency[] | undefined): boolean;
+/**
+ * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
+ * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranch} - for the array-based version
+ */
+export declare function happensInEveryBranchSet(controlDependencies: ReadonlySet<ControlDependency> | undefined): boolean;
 /**
  * Checks whether the given dataflow information always exits (i.e., if there is a non-default exit point in every branch).
  * @see {@link ExitPoint} - for the different types of exit points

package/dataflow/info.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addNonDefaultExitPoints = addNonDefaultExitPoints;
 exports.initializeCleanDataflowInformation = initializeCleanDataflowInformation;
 exports.happensInEveryBranch = happensInEveryBranch;
+exports.happensInEveryBranchSet = happensInEveryBranchSet;
 exports.alwaysExits = alwaysExits;
 exports.filterOutLoopExitPoints = filterOutLoopExitPoints;
 exports.diffControlDependency = diffControlDependency;
@@ -33,6 +34,7 @@ function initializeCleanDataflowInformation(entryPoint, data) {
 /**
  * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
  * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranchSet} - for the set-based version
  */
 function happensInEveryBranch(controlDependencies) {
     if (controlDependencies === undefined) {
@@ -43,6 +45,9 @@ function happensInEveryBranch(controlDependencies) {
         /* this happens only when we have no idea and require more analysis */
         return false;
     }
+    return coversSet(controlDependencies);
+}
+function coversSet(controlDependencies) {
     const trues = [];
     const falseSet = new Set();
     for (const { id, when } of controlDependencies) {
@@ -55,6 +60,22 @@ function happensInEveryBranch(controlDependencies) {
     }
     return trues.every(id => falseSet.has(id));
 }
+/**
+ * Checks whether the given control dependencies are exhaustive (i.e. if for every control dependency on a boolean,
+ * the list contains a dependency on the `true` and on the `false` case).
+ * @see {@link happensInEveryBranch} - for the array-based version
+ */
+function happensInEveryBranchSet(controlDependencies) {
+    if (controlDependencies === undefined) {
+        /* the cds are unconstrained */
+        return true;
+    }
+    else if (controlDependencies.size === 0) {
+        /* this happens only when we have no idea and require more analysis */
+        return false;
+    }
+    return coversSet(controlDependencies);
+}
 /**
  * Checks whether the given dataflow information always exits (i.e., if there is a non-default exit point in every branch).
  * @see {@link ExitPoint} - for the different types of exit points

package/dataflow/internal/linker.js

@@ -29,9 +29,7 @@ const prefix_1 = require("../../util/prefix");
  */
 function findNonLocalReads(graph, ignore) {
     const ignores = new Set(ignore.map(i => i.nodeId));
-    const ids = new Set(graph.vertices(true)
-        .filter(([_, info]) => info.tag === vertex_1.VertexType.Use || info.tag === vertex_1.VertexType.FunctionCall)
-        .map(([id, _]) => id));
+    const ids = new Set(graph.vertexIdsOfType(vertex_1.VertexType.Use).concat(graph.vertexIdsOfType(vertex_1.VertexType.FunctionCall)));
     /* find all variable use ids which do not link to a given id */
     const nonLocalReads = [];
     for (const id of ids) {
@@ -202,10 +200,8 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
  */
 function linkFunctionCalls(graph, idMap, thisGraph) {
     const calledFunctionDefinitions = [];
-    for (const [id, info] of thisGraph.vertices(true)) {
-        if (info.tag === vertex_1.VertexType.FunctionCall) {
-            linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
-        }
+    for (const [id, info] of thisGraph.verticesOfType(vertex_1.VertexType.FunctionCall)) {
+        linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefinitions);
     }
     return calledFunctionDefinitions;
 }
@@ -241,7 +237,7 @@ function getAllFunctionCallTargets(call, graph, environment) {
  * Finds all linked function definitions starting from the given set of read ids.
  */
 function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
-    let potential = [...functionDefinitionReadIds];
+    let potential = functionDefinitionReadIds.values().toArray();
     const visited = new Set();
     const result = new Set();
     const builtIns = new Set();
@@ -257,8 +253,9 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
             continue;
         }
         visited.add(currentId);
-        const outgoingEdges = [...currentInfo[1]];
-        const returnEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
+        const outgoingEdges = currentInfo[1].entries().toArray();
+        const returnEdges = outgoingEdges
+            .filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, edge_1.EdgeType.Returns));
         if (returnEdges.length > 0) {
             // only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
             potential = potential.concat(returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
@@ -270,7 +267,9 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
             result.add(currentInfo[0]);
         }
         // trace all joined reads
-        potential = potential.concat(followEdges.map(([target]) => target).filter(id => !visited.has(id)));
+        potential = potential.concat(followEdges
+            .map(([target]) => target)
+            .filter(id => !visited.has(id)));
     }
     return [result, builtIns];
 }

package/dataflow/internal/process/functions/call/argument/make-argument.d.ts

@@ -3,10 +3,10 @@ import type { AstIdMap, ParentInformation } from '../../../../../../r-bridge/lan
 import { EmptyArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RUnnamedArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
 /**
- *
+ * Converts a normalized node into an unnamed argument (wraps it with an argument node).
  */
 export declare function toUnnamedArgument<OtherInfo>(node: RNode<OtherInfo & ParentInformation> | undefined, idMap: AstIdMap<OtherInfo>): RUnnamedArgument<OtherInfo & ParentInformation> | typeof EmptyArgument;
 /**
- *
+ * Wraps the given nodes as unnamed arguments where necessary.
  */
 export declare function wrapArgumentsUnnamed<OtherInfo>(nodes: readonly (RNode<OtherInfo & ParentInformation> | typeof EmptyArgument | undefined)[], idMap: AstIdMap<OtherInfo>): ("<>" | import("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument").RArgument<OtherInfo & ParentInformation>)[];

package/dataflow/internal/process/functions/call/argument/make-argument.js

@@ -7,7 +7,7 @@ const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const voidRange = (0, range_1.rangeFrom)(-1, -1, -1, -1);
 /**
- *
+ * Converts a normalized node into an unnamed argument (wraps it with an argument node).
  */
 function toUnnamedArgument(node, idMap) {
     if (node === undefined) {
@@ -16,7 +16,6 @@ function toUnnamedArgument(node, idMap) {
     const arg = {
         type: type_1.RType.Argument,
         lexeme: node.lexeme ?? '',
-        // is this correct?
         location: node.location ?? voidRange,
         info: {
             ...node.info,
@@ -29,7 +28,7 @@ function toUnnamedArgument(node, idMap) {
     return arg;
 }
 /**
- *
+ * Wraps the given nodes as unnamed arguments where necessary.
  */
 function wrapArgumentsUnnamed(nodes, idMap) {
     return nodes.map(n => n === r_function_call_1.EmptyArgument || n?.type === type_1.RType.Argument ? n : toUnnamedArgument(n, idMap));

package/dataflow/internal/process/functions/call/argument/unpack-argument.d.ts

@@ -2,5 +2,11 @@ import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 /**
  * Retrieve the value from an argument, if it is not empty.
+ * @see {@link unpackArg} - to specifically retrieve non-named arguments
  */
-export declare function unpackArgument<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined, noNameOnly?: boolean): RNode<OtherInfo> | undefined;
+export declare function unpackNonameArg<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;
+/**
+ * Retrieve the value from a non-named argument, if it is not empty.
+ * @see {@link unpackNonameArg} - to specifically retrieve non-named arguments
+ */
+export declare function unpackArg<OtherInfo>(arg: RFunctionArgument<OtherInfo> | undefined): RNode<OtherInfo> | undefined;

package/dataflow/internal/process/functions/call/argument/unpack-argument.js

@@ -1,11 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unpackArgument = unpackArgument;
+exports.unpackNonameArg = unpackNonameArg;
+exports.unpackArg = unpackArg;
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 /**
  * Retrieve the value from an argument, if it is not empty.
+ * @see {@link unpackArg} - to specifically retrieve non-named arguments
  */
-function unpackArgument(arg, noNameOnly = true) {
-    return arg === undefined || arg === r_function_call_1.EmptyArgument || (noNameOnly && arg.name) ? undefined : arg.value;
+function unpackNonameArg(arg) {
+    return arg === r_function_call_1.EmptyArgument || arg?.name !== undefined ? undefined : arg?.value;
+}
+/**
+ * Retrieve the value from a non-named argument, if it is not empty.
+ * @see {@link unpackNonameArg} - to specifically retrieve non-named arguments
+ */
+function unpackArg(arg) {
+    return arg === r_function_call_1.EmptyArgument ? undefined : arg?.value;
 }
 //# sourceMappingURL=unpack-argument.js.map

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

@@ -20,6 +20,6 @@ export declare function processAccess<OtherInfo>(name: RSymbol<OtherInfo & Paren
     treatIndicesAsString: boolean;
 } & ForceArguments): DataflowInformation;
 /**
- *
+ * Converts symbol arguments to string arguments within the specified range.
  */
 export declare function symbolArgumentsToStrings<OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], firstIndexInclusive?: number, lastIndexInclusive?: number): RFunctionArgument<OtherInfo & ParentInformation>[];

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

@@ -7,12 +7,12 @@ const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model
 const logger_1 = require("../../../../../logger");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../../../graph/edge");
-const environment_1 = require("../../../../../environments/environment");
 const built_in_1 = require("../../../../../environments/built-in");
 const built_in_assignment_1 = require("./built-in-assignment");
 const identifier_1 = require("../../../../../environments/identifier");
 const vertex_1 = require("../../../../../graph/vertex");
 const containers_1 = require("../../../../../../util/containers");
+const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 function tableAssignmentProcessor(name, args, rootId, data, outInfo) {
     outInfo.definitionRootNodes.push(rootId);
     return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'table:assign' }).information;
@@ -71,12 +71,12 @@ function processAccess(name, args, rootId, data, config) {
          * ```
          * the read for a will use both accesses as potential definitions and not just the last one!
          */
-        unknownReferences: (0, environment_1.makeAllMaybe)(info.unknownReferences, info.graph, info.environment, false),
+        unknownReferences: (0, reference_to_maybe_1.makeAllMaybe)(info.unknownReferences, info.graph, info.environment, false),
         entryPoint: rootId,
         /** it is, to be precise, the accessed element we want to map to maybe */
         in: head === r_function_call_1.EmptyArgument ? info.in : info.in.map(ref => {
             if (ref.nodeId === head.value?.info.id) {
-                return (0, environment_1.makeReferenceMaybe)(ref, info.graph, info.environment, false);
+                return (0, reference_to_maybe_1.makeReferenceMaybe)(ref, info.graph, info.environment, false);
             }
             else {
                 return ref;
@@ -114,16 +114,16 @@ function processNumberBasedAccess(data, name, args, rootId, config, head) {
     if (head.value && outInfo.definitionRootNodes.length > 0) {
         (0, built_in_assignment_1.markAsAssignment)(fnCall.information, { type: identifier_1.ReferenceType.Variable, name: head.value.lexeme ?? '', nodeId: head.value.info.id, definedAt: rootId, controlDependencies: [] }, outInfo.definitionRootNodes, rootId, data);
     }
-    if (data.flowrConfig.solver.pointerTracking) {
+    if (data.ctx.config.solver.pointerTracking) {
         referenceAccessedIndices(args, data, fnCall, rootId, true);
     }
     return fnCall;
 }
 /**
- *
+ * Converts symbol arguments to string arguments within the specified range.
  */
 function symbolArgumentsToStrings(args, firstIndexInclusive = 1, lastIndexInclusive = args.length - 1) {
-    const newArgs = [...args];
+    const newArgs = args.slice();
     // if the argument is a symbol, we convert it to a string for this perspective
     for (let i = firstIndexInclusive; i <= lastIndexInclusive; i++) {
         const arg = newArgs[i];
@@ -159,7 +159,7 @@ function processStringBasedAccess(args, data, name, rootId, config) {
     const fnCall = (0, known_call_handling_1.processKnownFunctionCall)({ name, args: newArgs, rootId, data, forceArgs: config.forceArgs,
         origin: 'builtin:access'
     });
-    if (data.flowrConfig.solver.pointerTracking) {
+    if (data.ctx.config.solver.pointerTracking) {
         referenceAccessedIndices(newArgs, data, fnCall, rootId, false);
     }
     return fnCall;

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

@@ -60,7 +60,7 @@ function processApply(name, args, rootId, data, config) {
     else if (val.type === type_1.RType.Symbol) {
         functionId = val.info.id;
         if (resolveValue) {
-            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.flowrConfig.solver.variables }));
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: data.environment, idMap: data.completeAst.idMap, resolve: data.ctx.config.solver.variables, ctx: data.ctx }));
             if (resolved?.elements.length === 1 && resolved.elements[0].type === 'string') {
                 functionName = (0, r_value_1.isValue)(resolved.elements[0].value) ? resolved.elements[0].value.str : undefined;
             }
@@ -105,7 +105,7 @@ function processApply(name, args, rootId, data, config) {
             cds: data.controlDependencies,
             args: allOtherArguments, // same reference
             origin: ['function']
-        });
+        }, data.ctx.env.makeCleanEnv());
         information.graph.addEdge(rootId, rootFnId, edge_1.EdgeType.Calls | edge_1.EdgeType.Reads);
         information.graph.addEdge(rootId, functionId, edge_1.EdgeType.Calls | edge_1.EdgeType.Argument);
         information = {

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

@@ -51,4 +51,6 @@ export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfi
 export declare function markAsAssignment<OtherInfo>(information: {
     environment: REnvironmentInformation;
     graph: DataflowGraph;
-}, nodeToDefine: InGraphIdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, data: DataflowProcessorInformation<OtherInfo>, assignmentConfig?: AssignmentConfiguration): void;
+}, nodeToDefine: InGraphIdentifierDefinition & {
+    name: string;
+}, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, data: DataflowProcessorInformation<OtherInfo>, assignmentConfig?: AssignmentConfiguration): void;

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

@@ -112,7 +112,7 @@ args, rootId, data, config) {
         }
         else {
             // try to resolve the variable first
-            const n = (0, alias_tracking_1.resolveIdToValue)(target.info.id, { environment: data.environment, resolve: data.flowrConfig.solver.variables, idMap: data.completeAst.idMap, full: true });
+            const n = (0, alias_tracking_1.resolveIdToValue)(target.info.id, { environment: data.environment, resolve: data.ctx.config.solver.variables, idMap: data.completeAst.idMap, full: true, ctx: data.ctx });
             if (n.type === 'set' && n.elements.length === 1 && n.elements[0].type === 'string') {
                 const val = n.elements[0].value;
                 if ((0, r_value_1.isValue)(val)) {
@@ -187,8 +187,8 @@ args, rootId, data, config) {
     return info;
 }
 function extractSourceAndTarget(args) {
-    const source = (0, unpack_argument_1.unpackArgument)(args[1], false);
-    const target = (0, unpack_argument_1.unpackArgument)(args[0], false);
+    const source = (0, unpack_argument_1.unpackArg)(args[1]);
+    const target = (0, unpack_argument_1.unpackArg)(args[0]);
     return { source, target };
 }
 /**
@@ -259,7 +259,7 @@ function checkTargetReferenceType(source, sourceInfo) {
  * @param assignmentConfig   - configuration for the assignment processing
  */
 function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, data, assignmentConfig) {
-    if (data.flowrConfig.solver.pointerTracking) {
+    if (data.ctx.config.solver.pointerTracking) {
         let indicesCollection = undefined;
         if (sourceIds.length === 1) {
             // support for tracking indices.
@@ -288,7 +288,7 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
         }
         nodeToDefine.indicesCollection ??= indicesCollection;
     }
-    information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment, data.flowrConfig);
+    information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment, data.ctx.config);
     information.graph.setDefinitionOfVertex(nodeToDefine);
     if (!assignmentConfig?.quoteSource) {
         for (const sourceId of sourceIds) {
@@ -343,7 +343,7 @@ function processAssignmentToSymbol(config) {
         unknownReferences: [],
         entryPoint: rootId,
         in: readTargets,
-        out: [...writeNodes, ...readFromSourceWritten]
+        out: writeNodes.concat(readFromSourceWritten),
     };
 }
 //# sourceMappingURL=built-in-assignment.js.map

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

@@ -33,12 +33,12 @@ function processEvalCall(name, args, rootId, data, config) {
     if (config.includeFunctionCall) {
         information.graph.addEdge(rootId, args[0].value.info.id, edge_1.EdgeType.Returns);
     }
-    if (!data.flowrConfig.solver.evalStrings) {
+    if (!data.ctx.config.solver.evalStrings) {
         (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Skipping eval call ${JSON.stringify(evalArgument)} (disabled in config file)`);
         (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
     }
-    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap, data.flowrConfig);
+    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap, data.ctx);
     if (code) {
         const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
         data = {
@@ -60,17 +60,17 @@ function processEvalCall(name, args, rootId, data, config) {
             graph: result.reduce((acc, r) => acc.mergeWith(r.graph), information.graph),
             environment: result.reduce((acc, r) => (0, append_1.appendEnvironment)(acc, r.environment), information.environment),
             entryPoint: rootId,
-            out: [...information.out, ...result.flatMap(r => r.out)],
-            in: [...information.in, ...result.flatMap(r => r.in)],
-            unknownReferences: [...information.unknownReferences, ...result.flatMap(r => r.unknownReferences)],
-            exitPoints: [...information.exitPoints, ...result.flatMap(r => r.exitPoints)],
+            out: information.out.concat(result.flatMap(r => r.out)),
+            in: information.in.concat(result.flatMap(r => r.in)),
+            unknownReferences: information.unknownReferences.concat(result.flatMap(r => r.unknownReferences)),
+            exitPoints: information.exitPoints.concat(result.flatMap(r => r.exitPoints)),
         };
     }
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `Non-constant argument ${JSON.stringify(args)} for eval is currently not supported, skipping`);
     (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
     return information;
 }
-function resolveEvalToCode(evalArgument, env, idMap, config) {
+function resolveEvalToCode(evalArgument, env, idMap, ctx) {
     const val = evalArgument;
     if (val.type === type_1.RType.FunctionCall && val.named && val.functionName.content === 'parse') {
         const arg = val.arguments.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'text');
@@ -82,13 +82,13 @@ function resolveEvalToCode(evalArgument, env, idMap, config) {
             return [arg.value.content.str];
         }
         else if (arg.value?.type === type_1.RType.Symbol) {
-            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.value.info.id, { environment: env, idMap: idMap, resolve: config.solver.variables }));
+            const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(arg.value.info.id, { environment: env, idMap: idMap, resolve: ctx.config.solver.variables, ctx }));
             if (resolved) {
                 return (0, string_constants_1.collectStrings)(resolved.elements);
             }
         }
         else if (arg.value?.type === type_1.RType.FunctionCall && arg.value.named && ['paste', 'paste0'].includes(arg.value.functionName.content)) {
-            return handlePaste(config, arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : ['']);
+            return handlePaste(ctx.config, arg.value.arguments, env, idMap, arg.value.functionName.content === 'paste' ? [' '] : [''], ctx);
         }
         return undefined;
     }
@@ -101,7 +101,7 @@ function resolveEvalToCode(evalArgument, env, idMap, config) {
         return undefined;
     }
 }
-function getAsString(config, val, env, idMap) {
+function getAsString(config, val, env, idMap, ctx) {
     if (!val) {
         return undefined;
     }
@@ -109,17 +109,17 @@ function getAsString(config, val, env, idMap) {
         return [val.content.str];
     }
     else if (val.type === type_1.RType.Symbol) {
-        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: env, idMap: idMap, resolve: config.solver.variables }));
+        const resolved = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(val.info.id, { environment: env, idMap: idMap, resolve: config.solver.variables, ctx }));
         if (resolved) {
             return (0, string_constants_1.collectStrings)(resolved.elements);
         }
     }
     return undefined;
 }
-function handlePaste(config, args, env, idMap, sepDefault) {
+function handlePaste(config, args, env, idMap, sepDefault, ctx) {
     const sepArg = args.find(v => v !== r_function_call_1.EmptyArgument && v.name?.content === 'sep');
     if (sepArg) {
-        const res = sepArg !== r_function_call_1.EmptyArgument && sepArg.value ? getAsString(config, sepArg.value, env, idMap) : undefined;
+        const res = sepArg !== r_function_call_1.EmptyArgument && sepArg.value ? getAsString(config, sepArg.value, env, idMap, ctx) : undefined;
         if (!res) {
             // sep not resolvable clearly / unknown
             return undefined;
@@ -128,7 +128,7 @@ function handlePaste(config, args, env, idMap, sepDefault) {
     }
     const allArgs = args
         .filter(v => v !== r_function_call_1.EmptyArgument && v.name?.content !== 'sep' && v.value)
-        .map(v => getAsString(config, v.value, env, idMap));
+        .map(v => getAsString(config, v.value, env, idMap, ctx));
     if (allArgs.some(assert_1.isUndefined)) {
         return undefined;
     }

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

@@ -7,7 +7,6 @@ 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 identifier_1 = require("../../../../../environments/identifier");
 const resolve_by_name_1 = require("../../../../../environments/resolve-by-name");
@@ -18,7 +17,7 @@ const built_in_1 = require("../../../../../environments/built-in");
 const overwrite_1 = require("../../../../../environments/overwrite");
 const logger_1 = require("../../../../../logger");
 const log_1 = require("../../../../../../util/log");
-const remove_1 = require("../../../../../environments/remove");
+const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 const dotDotDotAccess = /^\.\.\d+$/;
 function linkReadNameToWriteIfPossible(read, environments, listEnvironments, remainingRead, nextGraph) {
     const readName = read.name && dotDotDotAccess.test(read.name) ? '...' : read.name;
@@ -82,7 +81,10 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
                 // we update all definitions to be linked with the corresponding function call
                 // we, however, have to ignore expression-local writes!
                 if (localDefs.length > 0) {
-                    environment = (0, remove_1.removeAll)(localDefs, environment);
+                    environment = {
+                        current: environment.current.removeAll(localDefs.filter(d => (0, assert_1.isNotUndefined)(d.name))),
+                        level: environment.level
+                    };
                 }
                 if (callDependencies === null) {
                     callDependencies = nextGraph.getVertex(functionCall, true)?.cds;
@@ -97,7 +99,7 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
  *
  */
 function processExpressionList(name, args, rootId, data) {
-    const expressions = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
+    const expressions = args.map(unpack_argument_1.unpackNonameArg);
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `[expr list] with ${expressions.length} expressions`);
     let { environment } = data;
     // used to detect if a "write" happens within the same expression list
@@ -124,9 +126,9 @@ function processExpressionList(name, args, rootId, data) {
         // 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);
+            processed.out = (0, reference_to_maybe_1.makeAllMaybe)(processed.out, nextGraph, processed.environment, true);
+            processed.in = (0, reference_to_maybe_1.makeAllMaybe)(processed.in, nextGraph, processed.environment, false);
+            processed.unknownReferences = (0, reference_to_maybe_1.makeAllMaybe)(processed.unknownReferences, nextGraph, processed.environment, false);
         }
         (0, info_1.addNonDefaultExitPoints)(exitPoints, processed.exitPoints);
         out = out.concat(processed.out);
@@ -153,7 +155,7 @@ function processExpressionList(name, args, rootId, data) {
             controlDependencies: data.controlDependencies
         });
     }
-    const ingoing = [...remainingRead.values()].flat();
+    const ingoing = remainingRead.values().toArray().flat();
     const rootNode = data.completeAst.idMap.get(rootId);
     const withGroup = rootNode?.grouping;
     if (withGroup) {

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

@@ -12,9 +12,9 @@ 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 edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
+const reference_to_maybe_1 = require("../../../../../environments/reference-to-maybe");
 /**
  *
  */
@@ -23,7 +23,7 @@ function processForLoop(name, args, rootId, data) {
         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, origin: 'default' }).information;
     }
-    const [variableArg, vectorArg, bodyArg] = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
+    const [variableArg, vectorArg, bodyArg] = args.map(e => (0, unpack_argument_1.unpackNonameArg)(e));
     (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)) {
@@ -37,7 +37,7 @@ function processForLoop(name, args, rootId, data) {
     const headGraph = variable.graph.mergeWith(vector.graph);
     const writtenVariable = variable.unknownReferences.concat(variable.in);
     for (const write of writtenVariable) {
-        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments, data.flowrConfig);
+        headEnvironments = (0, define_1.define)({ ...write, definedAt: name.info.id, type: identifier_1.ReferenceType.Variable }, false, headEnvironments, data.ctx.config);
     }
     data = { ...data, controlDependencies: [...data.controlDependencies ?? [], { id: name.info.id, when: true }], environment: headEnvironments };
     const body = (0, processor_1.processDataflowFor)(bodyArg, data);
@@ -50,7 +50,7 @@ function processForLoop(name, args, rootId, data) {
         nextGraph.addEdge(write.nodeId, vector.entryPoint, edge_1.EdgeType.DefinedBy);
         nextGraph.setDefinitionOfVertex(write);
     }
-    const outgoing = variable.out.concat(writtenVariable, (0, environment_1.makeAllMaybe)(body.out, nextGraph, outEnvironment, true));
+    const outgoing = variable.out.concat(writtenVariable, (0, reference_to_maybe_1.makeAllMaybe)(body.out, nextGraph, outEnvironment, true));
     (0, linker_1.linkCircularRedefinitionsWithinALoop)(nextGraph, nameIdShares, body.out);
     (0, linker_1.reapplyLoopExitPoints)(body.exitPoints, body.in.concat(body.out, body.unknownReferences));
     (0, common_1.patchFunctionCall)({

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

@@ -6,6 +6,7 @@ import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { DataflowGraph } from '../../../../../graph/graph';
 import { type REnvironmentInformation } from '../../../../../environments/environment';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../../../../project/context/flowr-analyzer-context';
 /**
  * Process a function definition, i.e., `function(a, b) { ... }`
  */
@@ -13,7 +14,7 @@ export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<Other
 /**
  *
  */
-export declare function retrieveActiveEnvironment(callerEnvironment: REnvironmentInformation | undefined, baseEnvironment: REnvironmentInformation): REnvironmentInformation;
+export declare function retrieveActiveEnvironment(callerEnvironment: REnvironmentInformation | undefined, baseEnvironment: REnvironmentInformation, ctx: ReadOnlyFlowrAnalyzerContext): REnvironmentInformation;
 /**
  * Update the closure links of all nested function definitions
  * @param graph          - dataflow graph to collect the function definitions from and to update the closure links for