@eagleoutice/flowr 2.6.1 → 2.6.3

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;
@@ -17,7 +18,6 @@ function addNonDefaultExitPoints(existing, add) {
 /**
  * Initializes an empty {@link DataflowInformation} object with the given entry point and data.
  * This is to be used as a "starting point" when processing leaf nodes during the dataflow extraction.
- *
  * @see {@link DataflowInformation}
  */
 function initializeCleanDataflowInformation(entryPoint, data) {
@@ -34,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) {
@@ -44,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) {
@@ -56,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
@@ -69,6 +89,9 @@ function alwaysExits(data) {
 function filterOutLoopExitPoints(exitPoints) {
     return exitPoints.filter(({ type }) => type === 1 /* ExitPointType.Return */ || type === 0 /* ExitPointType.Default */);
 }
+/**
+ * Calculates the difference between two control dependencies.
+ */
 function diffControlDependency(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -83,6 +106,9 @@ function diffControlDependency(a, b, info) {
         info.report.addComment(`${info.position}Different control dependency when. ${info.leftname}: ${a.when} vs. ${info.rightname}: ${b.when}`);
     }
 }
+/**
+ * Calculates the difference between two lists of control dependencies.
+ */
 function diffControlDependencies(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {

package/dataflow/internal/linker.d.ts

@@ -1,22 +1,33 @@
 import { DefaultMap } from '../../util/collections/defaultmap';
-import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { IdentifierReference } from '../environments/identifier';
-import type { DataflowGraph, FunctionArgument } from '../graph/graph';
+import { type NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { type IdentifierReference } from '../environments/identifier';
+import { type DataflowGraph, type FunctionArgument } from '../graph/graph';
 import type { RParameter } from '../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { AstIdMap, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexInfo } from '../graph/vertex';
-import type { BuiltIn } from '../environments/built-in';
+import { type DataflowGraphVertexFunctionCall, type DataflowGraphVertexFunctionDefinition, type DataflowGraphVertexInfo } from '../graph/vertex';
+import { type BuiltIn } from '../environments/built-in';
 import type { REnvironmentInformation } from '../environments/environment';
 import type { ExitPoint } from '../info';
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
+/**
+ * Find all reads within the graph that do not reference a local definition in the graph.
+ */
 export declare function findNonLocalReads(graph: DataflowGraph, ignore: readonly IdentifierReference[]): IdentifierReference[];
+/**
+ * Produces a map from names to all identifier references sharing that name.
+ */
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;
+/**
+ * Links the given arguments to the given parameters within the given graph.
+ */
 export declare function linkArgumentsOnCall(args: FunctionArgument[], params: RParameter<ParentInformation>[], graph: DataflowGraph): void;
+/**
+ * Links a function call with a single target function definition.
+ */
 export declare function linkFunctionCallWithSingleTarget(graph: DataflowGraph, def: DataflowGraphVertexFunctionDefinition, info: DataflowGraphVertexFunctionCall, idMap: AstIdMap): void;
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
- *
  * @param graph     - The graph to use for search and resolution traversals (ideally a superset of the `thisGraph`)
  * @param idMap     - The map to resolve ids to names
  * @param thisGraph - The graph to search for function calls in
@@ -29,20 +40,22 @@ export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap,
  * convenience function returning all known call targets, as well as the name source which defines them
  */
 export declare function getAllFunctionCallTargets(call: NodeId, graph: DataflowGraph, environment?: REnvironmentInformation): NodeId[];
+/**
+ * Finds all linked function definitions starting from the given set of read ids.
+ */
 export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): [Set<DataflowGraphVertexInfo>, Set<BuiltIn>];
 /**
  * This method links a set of read variables to definitions in an environment.
- *
  * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
  * @param environmentInformation             - The environment information to link against
  * @param givenInputs                        - The existing list of inputs that might be extended
  * @param graph                              - The graph to enter the found links
  * @param maybeForRemaining                  - Each input that can not be linked, will be added to `givenInputs`. If this flag is `true`, it will be marked as `maybe`.
- *
  * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
  */
 export declare function linkInputs(referencesToLinkAgainstEnvironment: readonly IdentifierReference[], environmentInformation: REnvironmentInformation, givenInputs: IdentifierReference[], graph: DataflowGraph, maybeForRemaining: boolean): IdentifierReference[];
-/** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
+/**
+ * all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
  * e.g. with:
  * ```R
  * for(i in 1:10) {
@@ -52,4 +65,7 @@ export declare function linkInputs(referencesToLinkAgainstEnvironment: readonly
  * `x_2` must get a read marker to `x_1` as `x_1` is the active redefinition in the second loop iteration.
  */
 export declare function linkCircularRedefinitionsWithinALoop(graph: DataflowGraph, openIns: NameIdMap, outgoing: readonly IdentifierReference[]): void;
+/**
+ * Reapplies the loop exit points' control dependencies to the given identifier references.
+ */
 export declare function reapplyLoopExitPoints(exits: readonly ExitPoint[], references: readonly IdentifierReference[]): void;

package/dataflow/internal/linker.js

@@ -24,6 +24,9 @@ const vertex_1 = require("../graph/vertex");
 const resolve_by_name_1 = require("../environments/resolve-by-name");
 const built_in_1 = require("../environments/built-in");
 const prefix_1 = require("../../util/prefix");
+/**
+ * Find all reads within the graph that do not reference a local definition in the graph.
+ */
 function findNonLocalReads(graph, ignore) {
     const ignores = new Set(ignore.map(i => i.nodeId));
     const ids = new Set(graph.vertices(true)
@@ -64,6 +67,9 @@ function findNonLocalReads(graph, ignore) {
     }
     return nonLocalReads;
 }
+/**
+ * Produces a map from names to all identifier references sharing that name.
+ */
 function produceNameSharedIdMap(references) {
     const nameIdShares = new defaultmap_1.DefaultMap(() => []);
     for (const reference of references) {
@@ -73,6 +79,9 @@ function produceNameSharedIdMap(references) {
     }
     return nameIdShares;
 }
+/**
+ * Links the given arguments to the given parameters within the given graph.
+ */
 function linkArgumentsOnCall(args, params, graph) {
     const nameArgMap = new Map(args.filter(graph_1.isNamedArgument).map(a => [a.name, a]));
     const nameParamMap = new Map(params.filter(p => p?.name?.content !== undefined).map(p => [p.name.content, p]));
@@ -136,6 +145,9 @@ function linkFunctionCallArguments(targetId, idMap, functionCallName, functionRo
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `linking arguments for ${functionCallName} (${functionRootId}) to ${JSON.stringify(linkedFunction.location)}`);
     linkArgumentsOnCall(callArgs, linkedFunction.parameters, finalGraph);
 }
+/**
+ * Links a function call with a single target function definition.
+ */
 function linkFunctionCallWithSingleTarget(graph, def, info, idMap) {
     const id = info.id;
     if (info.environment !== undefined) {
@@ -184,7 +196,6 @@ function linkFunctionCall(graph, id, info, idMap, thisGraph, calledFunctionDefin
 /**
  * Returns the called functions within the current graph, which can be used to merge the environments with the call.
  * Furthermore, it links the corresponding arguments.
- *
  * @param graph     - The graph to use for search and resolution traversals (ideally a superset of the `thisGraph`)
  * @param idMap     - The map to resolve ids to names
  * @param thisGraph - The graph to search for function calls in
@@ -226,8 +237,11 @@ function getAllFunctionCallTargets(call, graph, environment) {
     }
     return found;
 }
+/**
+ * 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();
@@ -243,11 +257,12 @@ 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)));
+            potential = potential.concat(returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
             continue;
         }
         const followBits = edge_1.EdgeType.Reads | edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall;
@@ -256,19 +271,19 @@ 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];
 }
 /**
  * This method links a set of read variables to definitions in an environment.
- *
  * @param referencesToLinkAgainstEnvironment - The set of references to link against the environment
  * @param environmentInformation             - The environment information to link against
  * @param givenInputs                        - The existing list of inputs that might be extended
  * @param graph                              - The graph to enter the found links
  * @param maybeForRemaining                  - Each input that can not be linked, will be added to `givenInputs`. If this flag is `true`, it will be marked as `maybe`.
- *
  * @returns the given inputs, possibly extended with the remaining inputs (those of `referencesToLinkAgainstEnvironment` that could not be linked against the environment)
  */
 function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation, givenInputs, graph, maybeForRemaining) {
@@ -298,7 +313,8 @@ function linkInputs(referencesToLinkAgainstEnvironment, environmentInformation,
     // data.graph.get(node.id).definedAtPosition = false
     return givenInputs;
 }
-/** all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
+/**
+ * all loops variables which are open read (not already bound by a redefinition within the loop) get a maybe read marker to their last definition within the loop
  * e.g. with:
  * ```R
  * for(i in 1:10) {
@@ -326,6 +342,9 @@ function linkCircularRedefinitionsWithinALoop(graph, openIns, outgoing) {
         }
     }
 }
+/**
+ * Reapplies the loop exit points' control dependencies to the given identifier references.
+ */
 function reapplyLoopExitPoints(exits, references) {
     // just apply the cds of all exit points not already present
     const exitCds = new Set(exits.flatMap(e => e.controlDependencies).filter(assert_1.isNotUndefined));
@@ -333,11 +352,11 @@ function reapplyLoopExitPoints(exits, references) {
         for (const cd of exitCds) {
             if (ref.controlDependencies) {
                 if (!ref.controlDependencies?.find(c => c.id === cd.id && c.when === cd.when)) {
-                    ref.controlDependencies.push(cd);
+                    ref.controlDependencies.push({ ...cd, byIteration: true });
                 }
             }
             else {
-                ref.controlDependencies = [cd];
+                ref.controlDependencies = [{ ...cd, byIteration: true }];
             }
         }
     }

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

@@ -2,5 +2,11 @@ import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model'
 import type { AstIdMap, ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 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

@@ -6,6 +6,9 @@ const range_1 = require("../../../../../../util/range");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 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) {
         return r_function_call_1.EmptyArgument;
@@ -13,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,
@@ -25,6 +27,9 @@ function toUnnamedArgument(node, idMap) {
     idMap.set(arg.info.id, node);
     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

@@ -1,4 +1,4 @@
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 /**
  * Retrieve the value from an argument, if it is not empty.

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

@@ -1,7 +1,7 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type 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';
@@ -19,4 +19,7 @@ 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;
 } & 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

@@ -114,13 +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];
@@ -156,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;
@@ -201,7 +204,6 @@ function referenceAccessedIndices(newArgs, data, fnCall, rootId, isIndexBasedAcc
 /**
  * Creates edges of type {@link EdgeType.Reads} to the accessed Indices and their sub-indices starting from
  * the node with {@link parentNodeId}.
- *
  * @param accessedIndicesCollection - All indices that were accessed by the access operation
  * @param fnCall                    - The {@link ProcessKnownFunctionCallResult} of the access operation
  * @param parentNodeId              - {@link NodeId} of the parent from which the edge starts

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

@@ -1,6 +1,6 @@
 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 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';
@@ -17,4 +17,7 @@ export interface BuiltInApplyConfiguration extends MergeableRecord {
     /** Should the value of the function be resolved? */
     readonly resolveValue?: boolean;
 }
+/**
+ *
+ */
 export declare function processApply<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: BuiltInApplyConfiguration): DataflowInformation;

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

@@ -14,6 +14,9 @@ const general_1 = require("../../../../../eval/values/general");
 const r_value_1 = require("../../../../../eval/values/r-value");
 const log_1 = require("../../../../../../util/log");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+/**
+ *
+ */
 function processApply(name, args, rootId, data, config) {
     const { indexOfFunction = 1, nameOfFunctionArgument, unquoteFunction, resolveInEnvironment, resolveValue } = config;
     /* as the length is one-based and the argument filter mapping is zero-based, we do not have to subtract 1 */
@@ -57,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 }));
             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;
             }

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

@@ -5,8 +5,8 @@ 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';
-import type { InGraphIdentifierDefinition } from '../../../../../environments/identifier';
-import type { ContainerIndicesCollection } from '../../../../../graph/vertex';
+import { type InGraphIdentifierDefinition } from '../../../../../environments/identifier';
+import { type ContainerIndicesCollection } from '../../../../../graph/vertex';
 import type { ForceArguments } from '../common';
 import type { REnvironmentInformation } from '../../../../../environments/environment';
 import type { DataflowGraph } from '../../../../../graph/graph';

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 });
             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)) {
@@ -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.d.ts

@@ -1,9 +1,12 @@
 import { type DataflowProcessorInformation } from '../../../../../processor';
-import type { DataflowInformation } from '../../../../../info';
-import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type DataflowInformation } from '../../../../../info';
+import { type ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/**
+ *
+ */
 export declare function processEvalCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     /** should this produce an explicit source function call in the graph? */
     includeFunctionCall?: boolean;

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

@@ -18,6 +18,9 @@ const string_constants_1 = require("../../../../../eval/values/string/string-con
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const arrays_1 = require("../../../../../../util/collections/arrays");
+/**
+ *
+ */
 function processEvalCall(name, args, rootId, data, config) {
     if (args.length !== 1 || args[0] === r_function_call_1.EmptyArgument || !args[0].value) {
         logger_1.dataflowLogger.warn(`Expected exactly one argument for eval currently, but got ${args.length} instead, skipping`);
@@ -30,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.config);
     if (code) {
         const idGenerator = (0, decorate_1.sourcedDeterministicCountingIdGenerator)(name.lexeme + '::' + rootId, name.location);
         data = {
@@ -57,10 +60,10 @@ 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`);

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

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

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

@@ -93,6 +93,9 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
     }
     return inputEnvironment;
 }
+/**
+ *
+ */
 function processExpressionList(name, args, rootId, data) {
     const expressions = args.map(e => (0, unpack_argument_1.unpackArgument)(e));
     (0, log_1.expensiveTrace)(logger_1.dataflowLogger, () => `[expr list] with ${expressions.length} expressions`);
@@ -150,7 +153,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.d.ts

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

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

@@ -15,6 +15,9 @@ const append_1 = require("../../../../../environments/append");
 const environment_1 = require("../../../../../environments/environment");
 const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
+/**
+ *
+ */
 function processForLoop(name, args, rootId, data) {
     if (args.length !== 3) {
         logger_1.dataflowLogger.warn(`For-Loop ${name.content} does not have three arguments, skipping`);
@@ -34,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);

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

@@ -1,12 +1,18 @@
-import type { DataflowProcessorInformation } from '../../../../../processor';
-import type { DataflowInformation } from '../../../../../info';
+import { type DataflowProcessorInformation } from '../../../../../processor';
+import { type DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { DataflowGraph } from '../../../../../graph/graph';
-import type { REnvironmentInformation } from '../../../../../environments/environment';
+import { type REnvironmentInformation } from '../../../../../environments/environment';
+/**
+ * Process a function definition, i.e., `function(a, b) { ... }`
+ */
 export declare function processFunctionDefinition<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;
+/**
+ *
+ */
 export declare function retrieveActiveEnvironment(callerEnvironment: REnvironmentInformation | undefined, baseEnvironment: REnvironmentInformation): REnvironmentInformation;
 /**
  * Update the closure links of all nested function definitions