@eagleoutice/flowr 2.6.3 → 2.7.0

package/dataflow/graph/diff-dataflow-graph.js

@@ -207,8 +207,8 @@ function diffVertices(ctx) {
                 }
             }
         }
-        if (lInfo.tag === 'function-definition') {
-            if (rInfo.tag !== 'function-definition') {
+        if (lInfo.tag === vertex_1.VertexType.FunctionDefinition) {
+            if (rInfo.tag !== vertex_1.VertexType.FunctionDefinition) {
                 ctx.report.addComment(`Vertex ${id} differs in tags. ${ctx.leftname}: ${lInfo.tag} vs. ${ctx.rightname}: ${rInfo.tag}`, { tag: 'vertex', id });
             }
             else {

package/dataflow/graph/graph.d.ts

@@ -4,6 +4,7 @@ import { type DataflowGraphVertexArgument, type DataflowGraphVertexFunctionCall,
 import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { Identifier, IdentifierDefinition, IdentifierReference } from '../environments/identifier';
 import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type REnvironmentInformation } from '../environments/environment';
 import type { AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { LinkTo } from '../../queries/catalog/call-context-query/call-context-query-format';
 /**
@@ -71,6 +72,7 @@ export interface DataflowGraphJson {
     readonly rootVertices: NodeId[];
     readonly vertexInformation: [NodeId, DataflowGraphVertexInfo][];
     readonly edgeInformation: [NodeId, [NodeId, DataflowGraphEdge][]][];
+    readonly _unknownSideEffects: UnknownSideEffect[];
 }
 /**
  * An unknown side effect describes something that we cannot handle correctly (in all cases).
@@ -98,7 +100,6 @@ export type UnknownSideEffect = NodeId | {
  * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
-    private static DEFAULT_ENVIRONMENT;
     private _idMap;
     private readonly _unknownSideEffects;
     constructor(idMap: AstIdMap | undefined);
@@ -108,6 +109,8 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     private vertexInformation;
     /** All edges in the complete graph (including those nested in function definition) */
     private edgeInformation;
+    private types;
+    toJSON(): DataflowGraphJson;
     /**
      * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
      * @param id                      - The id of the node to get
@@ -147,6 +150,10 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
      * @see #edges
      */
     vertices(includeDefinedFunctions: boolean): MapIterator<[NodeId, Vertex]>;
+    verticesOfType<T extends Vertex['tag']>(type: T): MapIterator<[NodeId, Vertex & {
+        tag: T;
+    }]>;
+    vertexIdsOfType<T extends Vertex['tag']>(type: T): NodeId[];
     /**
      * @returns the ids of all edges in the graph together with their edge information
      * @see #vertices
@@ -166,13 +173,14 @@ export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = Data
     /**
      * 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 fallbackEnv - A clean environment to use if no environment is given in the vertex
      * @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.
      * @param overwrite - If true, this will overwrite the vertex if it already exists in the graph (based on the id).
      * @see DataflowGraphVertexInfo
      * @see DataflowGraphVertexArgument
      */
-    addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, asRoot?: boolean, overwrite?: boolean): this;
+    addVertex(vertex: DataflowGraphVertexArgument & Omit<Vertex, keyof DataflowGraphVertexArgument>, fallbackEnv: REnvironmentInformation, asRoot?: boolean, overwrite?: boolean): this;
     /** {@inheritDoc} */
     addEdge(from: NodeId, to: NodeId, type: EdgeType | number): this;
     /** {@inheritDoc} */

package/dataflow/graph/graph.js

@@ -51,7 +51,6 @@ function getReferenceOfArgument(arg) {
  * @see {@link emptyGraph|`emptyGraph`} - to create an empty graph (useful in tests)
  */
 class DataflowGraph {
-    static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
     /*
      * Set of vertices which have sideEffects that we do not know anything about.
@@ -60,7 +59,6 @@ class DataflowGraph {
      */
     _unknownSideEffects = new Set();
     constructor(idMap) {
-        DataflowGraph.DEFAULT_ENVIRONMENT ??= (0, environment_1.initializeCleanEnvironments)();
         this._idMap = idMap;
     }
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
@@ -69,6 +67,15 @@ class DataflowGraph {
     vertexInformation = new Map();
     /** All edges in the complete graph (including those nested in function definition) */
     edgeInformation = new Map();
+    types = new Map();
+    toJSON() {
+        return {
+            rootVertices: Array.from(this.rootVertices),
+            vertexInformation: Array.from(this.vertexInformation.entries()),
+            edgeInformation: Array.from(this.edgeInformation.entries()).map(([id, edges]) => [id, Array.from(edges.entries())]),
+            _unknownSideEffects: Array.from(this._unknownSideEffects)
+        };
+    }
     /**
      * Get the {@link DataflowGraphVertexInfo} attached to a node as well as all outgoing edges.
      * @param id                      - The id of the node to get
@@ -150,6 +157,15 @@ class DataflowGraph {
             }
         }
     }
+    *verticesOfType(type) {
+        const ids = this.types.get(type) ?? [];
+        for (const id of ids) {
+            yield [id, this.vertexInformation.get(id)];
+        }
+    }
+    vertexIdsOfType(type) {
+        return this.types.get(type) ?? [];
+    }
     /**
      * @returns the ids of all edges in the graph together with their edge information
      * @see #vertices
@@ -177,24 +193,32 @@ class DataflowGraph {
     /**
      * 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 fallbackEnv - A clean environment to use if no environment is given in the vertex
      * @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.
      * @param overwrite - If true, this will overwrite the vertex if it already exists in the graph (based on the id).
      * @see DataflowGraphVertexInfo
      * @see DataflowGraphVertexArgument
      */
-    addVertex(vertex, asRoot = true, overwrite = false) {
+    addVertex(vertex, fallbackEnv, asRoot = true, overwrite = false) {
         const oldVertex = this.vertexInformation.get(vertex.id);
         if (oldVertex !== undefined && !overwrite) {
             return this;
         }
-        const fallback = vertex.tag === vertex_1.VertexType.VariableDefinition || vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value || (vertex.tag === vertex_1.VertexType.FunctionCall && vertex.onlyBuiltin) ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
+        const fallback = vertex.tag === vertex_1.VertexType.FunctionDefinition || (vertex.tag === vertex_1.VertexType.FunctionCall && !vertex.onlyBuiltin) ? fallbackEnv : undefined;
         // keep a clone of the original environment
         const environment = vertex.environment ? (0, clone_1.cloneEnvironmentInformation)(vertex.environment) : fallback;
         this.vertexInformation.set(vertex.id, {
             ...vertex,
             environment
         });
+        const has = this.types.get(vertex.tag);
+        if (has) {
+            has.push(vertex.id);
+        }
+        else {
+            this.types.set(vertex.tag, [vertex.id]);
+        }
         if (asRoot) {
             this.rootVertices.add(vertex.id);
         }
@@ -246,6 +270,10 @@ class DataflowGraph {
             const currentInfo = this.vertexInformation.get(id);
             this.vertexInformation.set(id, currentInfo === undefined ? info : mergeNodeInfos(currentInfo, info));
         }
+        for (const [type, ids] of otherGraph.types) {
+            const existing = this.types.get(type);
+            this.types.set(type, existing ? existing.concat(ids) : ids.slice());
+        }
         this.mergeEdges(otherGraph);
         return this;
     }
@@ -289,7 +317,10 @@ class DataflowGraph {
     updateToFunctionCall(info) {
         const vertex = this.getVertex(info.id, true);
         (0, assert_1.guard)(vertex !== undefined && (vertex.tag === vertex_1.VertexType.Use || vertex.tag === vertex_1.VertexType.Value), () => `node must be a use or value node for ${JSON.stringify(info.id)} to update it to a function call but is ${vertex?.tag}`);
+        const previousTag = vertex.tag;
         this.vertexInformation.set(info.id, { ...vertex, ...info, tag: vertex_1.VertexType.FunctionCall });
+        this.types.set(previousTag, (this.types.get(previousTag) ?? []).filter(id => id !== info.id));
+        this.types.set(vertex_1.VertexType.FunctionCall, (this.types.get(vertex_1.VertexType.FunctionCall) ?? []).concat([info.id]));
     }
     /** If you do not pass the `to` node, this will just mark the node as maybe */
     addControlDependency(from, to, when) {
@@ -338,6 +369,9 @@ class DataflowGraph {
             }
         }
         graph.edgeInformation = new Map(data.edgeInformation.map(([id, edges]) => [id, new Map(edges)]));
+        for (const unknown of data._unknownSideEffects) {
+            graph._unknownSideEffects.add(unknown);
+        }
         return graph;
     }
 }
@@ -373,14 +407,9 @@ function envFromJson(json) {
     for (const [key, value] of Object.entries(json.memory)) {
         memory.set(key, value);
     }
-    const obj = {
-        id: json.id,
-        parent: parent,
-        memory
-    };
-    if (json.builtInEnv) {
-        obj.builtInEnv = true;
-    }
+    const obj = new environment_1.Environment(parent, json.builtInEnv);
+    obj.id = json.id;
+    obj.memory = memory;
     return obj;
 }
 function renvFromJson(json) {

package/dataflow/graph/invert-dfg.d.ts

@@ -1,5 +1,6 @@
 import { DataflowGraph } from './graph';
+import type { REnvironmentInformation } from '../environments/environment';
 /**
- *
+ * Inverts the given dataflow graph by reversing all edges.
  */
-export declare function invertDfg(graph: DataflowGraph): DataflowGraph;
+export declare function invertDfg(graph: DataflowGraph, cleanEnv: REnvironmentInformation): DataflowGraph;

package/dataflow/graph/invert-dfg.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.invertDfg = invertDfg;
 const graph_1 = require("./graph");
 /**
- *
+ * Inverts the given dataflow graph by reversing all edges.
  */
-function invertDfg(graph) {
+function invertDfg(graph, cleanEnv) {
     const invertedGraph = new graph_1.DataflowGraph(graph.idMap);
     for (const [, v] of graph.vertices(true)) {
-        invertedGraph.addVertex(v);
+        invertedGraph.addVertex(v, cleanEnv);
     }
     for (const [from, targets] of graph.edges()) {
         for (const [to, { types }] of targets) {

package/dataflow/graph/resolve-graph.d.ts

@@ -1,7 +1,8 @@
 import { DataflowGraph } from './graph';
 import { type AstIdMap } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 /**
  * Resolves the dataflow graph ids from slicing criterion form to ids.
  * This returns a **new** graph with the resolved ids.
  */
-export declare function resolveDataflowGraph(graph: DataflowGraph, idMap?: AstIdMap): DataflowGraph;
+export declare function resolveDataflowGraph(graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext, idMap?: AstIdMap): DataflowGraph;

package/dataflow/graph/resolve-graph.js

@@ -9,7 +9,7 @@ const edge_1 = require("./edge");
  * Resolves the dataflow graph ids from slicing criterion form to ids.
  * This returns a **new** graph with the resolved ids.
  */
-function resolveDataflowGraph(graph, idMap) {
+function resolveDataflowGraph(graph, ctx, idMap) {
     const resolveMap = idMap ?? graph.idMap;
     (0, assert_1.guard)(resolveMap !== undefined, 'idMap must be provided to resolve the graph');
     const cache = new Map();
@@ -36,7 +36,7 @@ function resolveDataflowGraph(graph, idMap) {
         resultGraph.addVertex({
             ...vertex,
             id: resolve(id)
-        }, roots.has(id));
+        }, ctx.env.makeCleanEnv(), roots.has(id));
     }
     /* recreate edges */
     for (const [from, targets] of graph.edges()) {

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,7 +102,7 @@ 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).

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;
 }

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.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;

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.ctx.config.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.ctx.config.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 };
 }
 /**

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

@@ -38,7 +38,7 @@ function processEvalCall(name, args, rootId, data, config) {
         (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
         return information;
     }
-    const code = resolveEvalToCode(evalArgument.value, data.environment, data.completeAst.idMap, data.ctx.config);
+    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 = {
@@ -70,7 +70,7 @@ function processEvalCall(name, args, rootId, data, config) {
     (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);

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)) {
@@ -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