@eagleoutice/flowr 2.4.0 → 2.4.1

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

@@ -10,7 +10,6 @@ import type { ContainerIndicesCollection } from '../../../../../graph/vertex';
 import type { ForceArguments } from '../common';
 import type { REnvironmentInformation } from '../../../../../environments/environment';
 import type { DataflowGraph } from '../../../../../graph/graph';
-import type { FlowrConfigOptions } from '../../../../../../config';
 export interface AssignmentConfiguration extends ForceArguments {
     readonly superAssignment?: boolean;
     readonly swapSourceAndTarget?: boolean;
@@ -44,10 +43,10 @@ export interface AssignmentToSymbolParameters<OtherInfo> extends AssignmentConfi
  * @param nodeToDefine       - `x`
  * @param sourceIds          - `v`
  * @param rootIdOfAssignment - `<-`
- * @param config             - The flowr config
+ * @param data               - The dataflow analysis fold backpack
  * @param assignmentConfig   - configuration for the assignment processing
  */
-export declare function markAsAssignment(information: {
+export declare function markAsAssignment<OtherInfo>(information: {
     environment: REnvironmentInformation;
     graph: DataflowGraph;
-}, nodeToDefine: InGraphIdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, config: FlowrConfigOptions, assignmentConfig?: AssignmentConfiguration): void;
+}, nodeToDefine: InGraphIdentifierDefinition, sourceIds: readonly NodeId[], rootIdOfAssignment: NodeId, data: DataflowProcessorInformation<OtherInfo>, assignmentConfig?: AssignmentConfiguration): void;

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

@@ -215,11 +215,11 @@ function checkTargetReferenceType(source, sourceInfo) {
  * @param nodeToDefine       - `x`
  * @param sourceIds          - `v`
  * @param rootIdOfAssignment - `<-`
- * @param config             - The flowr config
+ * @param data               - The dataflow analysis fold backpack
  * @param assignmentConfig   - configuration for the assignment processing
  */
-function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, config, assignmentConfig) {
-    if (config.solver.pointerTracking) {
+function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignment, data, assignmentConfig) {
+    if (data.flowrConfig.solver.pointerTracking) {
         let indicesCollection = undefined;
         if (sourceIds.length === 1) {
             // support for tracking indices.
@@ -248,7 +248,7 @@ function markAsAssignment(information, nodeToDefine, sourceIds, rootIdOfAssignme
         }
         nodeToDefine.indicesCollection ??= indicesCollection;
     }
-    information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment, config);
+    information.environment = (0, define_1.define)(nodeToDefine, assignmentConfig?.superAssignment, information.environment, data.flowrConfig);
     information.graph.setDefinitionOfVertex(nodeToDefine);
     if (!assignmentConfig?.quoteSource) {
         for (const sourceId of sourceIds) {
@@ -285,7 +285,7 @@ function processAssignmentToSymbol(config) {
     information.environment = (0, overwrite_1.overwriteEnvironment)(sourceArg.environment, targetArg.environment);
     // install assigned variables in environment
     for (const write of writeNodes) {
-        markAsAssignment(information, write, [source.info.id], rootId, data.flowrConfig, config);
+        markAsAssignment(information, write, [source.info.id], rootId, data, config);
     }
     information.graph.addEdge(rootId, targetArg.entryPoint, edge_1.EdgeType.Returns);
     if (quoteSource) {

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

@@ -50,24 +50,24 @@ function linkReadNameToWriteIfPossible(read, environments, listEnvironments, rem
 }
 function processNextExpression(currentElement, environment, listEnvironments, remainingRead, nextGraph) {
     // all inputs that have not been written until now are read!
-    for (const read of [...currentElement.in, ...currentElement.unknownReferences]) {
+    for (const read of currentElement.in.concat(currentElement.unknownReferences)) {
         linkReadNameToWriteIfPossible(read, environment, listEnvironments, remainingRead, nextGraph);
     }
 }
 function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextGraph, localDefs) {
     for (const { functionCall, called } of calledEnvs) {
-        const callDependencies = nextGraph.getVertex(functionCall, true)?.cds;
+        let callDependencies = null;
         for (const calledFn of called) {
             (0, assert_1.guard)(calledFn.tag === vertex_1.VertexType.FunctionDefinition, 'called function must be a function definition');
             // only merge the environments they have in common
-            let environment = calledFn.environment;
+            let environment = calledFn.subflow.environment;
             while (environment.level > inputEnvironment.level) {
                 environment = (0, scoping_1.popLocalEnvironment)(environment);
             }
             // update alle definitions to be defined at this function call
             let current = environment.current;
             let hasUpdate = false;
-            while (current !== undefined && current.id !== environment_1.BuiltInEnvironment.id) {
+            while (!current?.builtInEnv) {
                 for (const definitions of current.memory.values()) {
                     for (const def of definitions) {
                         if (!(0, built_in_1.isBuiltIn)(def.definedAt)) {
@@ -84,6 +84,9 @@ function updateSideEffectsForCalledFunctions(calledEnvs, inputEnvironment, nextG
                 if (localDefs.length > 0) {
                     environment = (0, remove_1.removeAll)(localDefs, environment);
                 }
+                if (callDependencies === null) {
+                    callDependencies = nextGraph.getVertex(functionCall, true)?.cds;
+                }
                 inputEnvironment = (0, overwrite_1.overwriteEnvironment)(inputEnvironment, environment, callDependencies);
             }
         }
@@ -110,7 +113,7 @@ function processExpressionList(name, args, rootId, data) {
             continue;
         }
         // use the current environments for processing
-        data = { ...data, environment: environment };
+        data.environment = environment;
         const processed = (0, processor_1.processDataflowFor)(expression, data);
         processedExpressions.push(processed);
         nextGraph.mergeWith(processed.graph);
@@ -140,7 +143,6 @@ function processExpressionList(name, args, rootId, data) {
             break;
         }
     }
-    logger_1.dataflowLogger.trace(`expression list exits with ${remainingRead.size} remaining read names`);
     if (defaultReturnExpr) {
         exitPoints.push({
             type: 0 /* ExitPointType.Default */,
@@ -148,7 +150,7 @@ function processExpressionList(name, args, rootId, data) {
             controlDependencies: data.controlDependencies
         });
     }
-    const ingoing = [...remainingRead.values()].flat();
+    const ingoing = [...remainingRead.values().flatMap(v => v)];
     const rootNode = data.completeAst.idMap.get(rootId);
     const withGroup = rootNode?.grouping;
     if (withGroup) {

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

@@ -107,7 +107,7 @@ function processFunctionDefinition(name, args, rootId, data) {
 // this is no longer necessary when we update environments to be back to front (e.g., with a list of environments)
 // this favors the bigger environment
 function retrieveActiveEnvironment(callerEnvironment, baseEnvironment) {
-    callerEnvironment ??= (0, environment_1.initializeCleanEnvironments)(true);
+    callerEnvironment ??= (0, environment_1.initializeCleanEnvironments)(undefined, true);
     let level = callerEnvironment.level ?? 0;
     if (baseEnvironment.level !== level) {
         while (baseEnvironment.level < level) {
@@ -212,7 +212,7 @@ function updateNestedFunctionCalls(graph, outEnvironment) {
     }
 }
 function prepareFunctionEnvironment(data) {
-    let env = (0, environment_1.initializeCleanEnvironments)();
+    let env = (0, environment_1.initializeCleanEnvironments)(data.builtInEnvironment.memory);
     for (let i = 0; i < data.environment.level + 1 /* add another env */; i++) {
         env = (0, scoping_1.pushLocalEnvironment)(env);
     }

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

@@ -31,7 +31,7 @@ function processRm(name, args, rootId, data) {
     }
     let env = res.environment;
     for (const name of names) {
-        env = (0, remove_1.remove)(name, env);
+        env = (0, remove_1.remove)(name, env, data.builtInEnvironment);
     }
     return {
         ...res,

package/dataflow/processor.d.ts

@@ -3,7 +3,7 @@
  */
 import type { ControlDependency, DataflowInformation } from './info';
 import type { NormalizedAst, ParentInformation, RNodeWithParent } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { REnvironmentInformation } from './environments/environment';
+import type { IEnvironment, REnvironmentInformation } from './environments/environment';
 import type { RParseRequest } from '../r-bridge/retriever';
 import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import type { KnownParserType, Parser } from '../r-bridge/parser';
@@ -36,6 +36,10 @@ export interface DataflowProcessorInformation<OtherInfo> {
      * The chain of control-flow {@link NodeId}s that lead to the current node (e.g., of known ifs).
      */
     readonly controlDependencies: ControlDependency[] | undefined;
+    /**
+     * The built-in environment
+     */
+    readonly builtInEnvironment: IEnvironment;
     /**
      * The flowr configuration used for environment seeding, and precision control
      */

package/documentation/doc-util/doc-env.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printEnvironmentToMarkdown = printEnvironmentToMarkdown;
-const environment_1 = require("../../dataflow/environments/environment");
 const dfg_1 = require("../../util/mermaid/dfg");
 function printEnvironmentToMarkdown(env) {
     if (env === undefined) {
         return '?? (error)';
     }
-    else if (env.id === environment_1.BuiltInEnvironment.id) {
+    else if (env.builtInEnv) {
         return `_Built-in Environment (${env.memory.size} entries)_`;
     }
     const lines = ['| Name | Definitions |', '|------|-------------|'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/queries/base-query-format.d.ts

@@ -1,6 +1,7 @@
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataflowInformation } from '../dataflow/info';
 import type { FlowrConfigOptions } from '../config';
+import type { SemVer } from 'semver';
 export interface BaseQueryFormat {
     /** used to select the query type :) */
     readonly type: string;
@@ -13,6 +14,7 @@ export interface BaseQueryResult {
     readonly '.meta': BaseQueryMeta;
 }
 export interface BasicQueryData {
+    readonly lib?: Record<string, SemVer>;
     readonly ast: NormalizedAst;
     readonly dataflow: DataflowInformation;
     readonly config: FlowrConfigOptions;

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -41,13 +41,7 @@ function satisfiesCallTargets(id, graph, callTarget) {
         .filter(([, { types }]) => (0, edge_1.edgeIncludesType)(types, edge_1.EdgeType.Calls))
         .map(([t]) => t);
     let builtIn = false;
-    if (callVertex.environment === undefined) {
-        /* if we have a call with an unbound environment,
-         * this only happens if we are sure of built-in relations and want to save references
-         */
-        builtIn = true;
-    }
-    else {
+    if (callVertex.environment !== undefined) {
         /*
          * for performance and scoping reasons, flowR will not identify the global linkage,
          * including any potential built-in mapping.
@@ -57,6 +51,12 @@ function satisfiesCallTargets(id, graph, callTarget) {
             builtIn = true;
         }
     }
+    else {
+        /* if we have a call with an unbound environment,
+         * this only happens if we are sure of built-in relations and want to save references
+         */
+        builtIn = true;
+    }
     switch (callTarget) {
         case CallTargets.Any:
             return callTargets;

package/queries/catalog/dependencies-query/dependencies-query-executor.js

@@ -15,6 +15,7 @@ const write_functions_1 = require("./function-info/write-functions");
 const function_info_1 = require("./function-info/function-info");
 const identify_link_to_last_call_relation_1 = require("../call-context-query/identify-link-to-last-call-relation");
 const resolve_argument_1 = require("../../../dataflow/eval/resolve/resolve-argument");
+const assert_1 = require("../../../util/assert");
 function collectNamespaceAccesses(data, libraries) {
     /* for libraries, we have to additionally track all uses of `::` and `:::`, for this we currently simply traverse all uses */
     (0, visitor_1.visitAst)(data.ast.ast, n => {
@@ -113,6 +114,8 @@ function dropInfoOnLinkedIds(linkedIds) {
     }
     return linkedIds.map(id => typeof id === 'object' ? id.id : id);
 }
+const readOnlyModes = new Set(['r', 'rt', 'rb']);
+const writeOnlyModes = new Set(['w', 'wt', 'wb', 'a', 'at', 'ab']);
 function getResults(data, results, kind, functions, makeInfo) {
     const kindEntries = Object.entries(results?.kinds[kind]?.subkinds ?? {});
     return kindEntries.flatMap(([name, results]) => results.flatMap(({ id, linkedIds }) => {
@@ -128,6 +131,21 @@ function getResults(data, results, kind, functions, makeInfo) {
             const record = (0, objects_1.compactRecord)(makeInfo(id, vertex, undefined, undefined, dropInfoOnLinkedIds(linkedIds)));
             return record ? [record] : [];
         }
+        else if (info.ignoreIf === 'mode-only-read' || info.ignoreIf === 'mode-only-write') {
+            (0, assert_1.guard)('mode' in (info.additionalArgs ?? {}), 'Need additional argument mode when checking for mode');
+            const margs = info.additionalArgs?.mode;
+            (0, assert_1.guard)(margs, 'Need additional argument mode when checking for mode');
+            const modeArgs = (0, resolve_argument_1.getArgumentStringValue)(data.config.solver.variables, data.dataflow.graph, vertex, margs.argIdx, margs.argName, margs.resolveValue);
+            const modeValues = modeArgs?.values().flatMap(v => [...v]) ?? [];
+            if (info.ignoreIf === 'mode-only-read' && modeValues.every(m => m && readOnlyModes.has(m))) {
+                // all modes are read-only, so we can ignore this
+                return [];
+            }
+            else if (info.ignoreIf === 'mode-only-write' && modeValues.every(m => m && writeOnlyModes.has(m))) {
+                // all modes are write-only, so we can ignore this
+                return [];
+            }
+        }
         const results = [];
         for (const [arg, values] of foundValues.entries()) {
             for (const value of values) {

package/queries/catalog/dependencies-query/function-info/function-info.d.ts

@@ -12,13 +12,17 @@ export type DependencyInfoLink = LinkTo<RegExp | string, Omit<FunctionInfo, 'nam
     when: DependencyInfoLinkConstraint;
 } | undefined>;
 export type DependencyInfoLinkAttachedInfo = DependencyInfoLink['attachLinkInfo'];
-export interface FunctionInfo {
-    package?: string;
-    name: string;
+export interface FunctionArgInfo {
     /** the index if the argument can be positional, unnamed in case of something like `...`, if the argument must be given with the name, please leave undefined */
     argIdx?: number | 'unnamed';
     argName?: string;
-    linkTo?: DependencyInfoLink[];
     resolveValue?: boolean | 'library';
-    ignoreIf?: 'arg-missing';
+}
+export interface FunctionInfo extends FunctionArgInfo {
+    package?: string;
+    name: string;
+    linkTo?: DependencyInfoLink[];
+    ignoreIf?: 'arg-missing' | 'mode-only-read' | 'mode-only-write';
+    /** additional info on arguments - e.g. for the mode flag */
+    additionalArgs?: Record<string, FunctionArgInfo>;
 }

package/queries/catalog/dependencies-query/function-info/read-functions.js

@@ -10,8 +10,8 @@ exports.ReadFunctions = [
     { package: 'base', name: 'read.dcf', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'base', name: 'scan', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'utils', name: 'read.fwf', argIdx: 0, argName: 'file', resolveValue: true },
-    { package: 'base', name: 'file', argIdx: 1, argName: 'open', resolveValue: true },
-    { package: 'base', name: 'url', argIdx: 1, argName: 'open', resolveValue: true },
+    { package: 'base', name: 'file', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-write', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
+    { package: 'base', name: 'url', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-write', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
     { package: 'base', name: 'load', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'base', name: 'gzfile', argIdx: 1, argName: 'open', resolveValue: true },
     { package: 'base', name: 'bzfile', argIdx: 1, argName: 'open', resolveValue: true },
@@ -22,6 +22,8 @@ exports.ReadFunctions = [
     { package: 'base', name: 'matrix', argIdx: 0, argName: 'data', resolveValue: true },
     { package: 'base', name: 'readRDS', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'base', name: 'readLines', argIdx: 0, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'readChar', argIdx: 0, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'readBin', argIdx: 0, argName: 'con', resolveValue: true },
     { package: 'base', name: 'readRenviron', argIdx: 0, argName: 'path', resolveValue: true },
     { package: 'readr', name: 'read_csv', argIdx: 0, argName: 'file', resolveValue: true },
     { package: 'readr', name: 'read_csv2', argIdx: 0, argName: 'file', resolveValue: true },

package/queries/catalog/dependencies-query/function-info/write-functions.js

@@ -19,6 +19,11 @@ exports.WriteFunctions = [
     { package: 'base', name: 'cat', linkTo: OutputRedirects, argName: 'file', resolveValue: true },
     { package: 'base', name: 'message', linkTo: OutputRedirects, resolveValue: true },
     { package: 'base', name: 'warning', linkTo: OutputRedirects, resolveValue: true },
+    { package: 'base', name: 'writeLines', argIdx: 1, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'writeChar', argIdx: 1, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'writeBin', argIdx: 1, argName: 'con', resolveValue: true },
+    { package: 'base', name: 'file', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-read', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
+    { package: 'base', name: 'url', argIdx: 0, argName: 'description', resolveValue: true, ignoreIf: 'mode-only-read', additionalArgs: { mode: { argIdx: 1, argName: 'open', resolveValue: true } } },
     { package: 'readr', name: 'write_csv', argIdx: 1, argName: 'file', resolveValue: true },
     { package: 'readr', name: 'write_csv2', argIdx: 1, argName: 'file', resolveValue: true },
     { package: 'readr', name: 'write_delim', argIdx: 1, argName: 'file', resolveValue: true },

package/queries/catalog/static-slice-query/static-slice-query-executor.d.ts

@@ -1,4 +1,4 @@
 import type { StaticSliceQuery, StaticSliceQueryResult } from './static-slice-query-format';
 import type { BasicQueryData } from '../../base-query-format';
 export declare function fingerPrintOfQuery(query: StaticSliceQuery): string;
-export declare function executeStaticSliceQuery({ dataflow: { graph }, ast, config }: BasicQueryData, queries: readonly StaticSliceQuery[]): StaticSliceQueryResult;
+export declare function executeStaticSliceQuery({ dataflow, ast, config }: BasicQueryData, queries: readonly StaticSliceQuery[]): StaticSliceQueryResult;

package/queries/catalog/static-slice-query/static-slice-query-executor.js

@@ -11,7 +11,7 @@ const _00_slice_1 = require("../../../core/steps/all/static-slicing/00-slice");
 function fingerPrintOfQuery(query) {
     return JSON.stringify(query);
 }
-function executeStaticSliceQuery({ dataflow: { graph }, ast, config }, queries) {
+function executeStaticSliceQuery({ dataflow, ast, config }, queries) {
     const start = Date.now();
     const results = {};
     for (const query of queries) {
@@ -21,7 +21,7 @@ function executeStaticSliceQuery({ dataflow: { graph }, ast, config }, queries)
         }
         const { criteria, noReconstruction, noMagicComments } = query;
         const sliceStart = Date.now();
-        const slice = (0, static_slicer_1.staticSlice)(graph, ast, criteria, query.direction ?? _00_slice_1.SliceDirection.Backward, config.solver.slicer?.threshold);
+        const slice = (0, static_slicer_1.staticSlice)(dataflow, ast, criteria, query.direction ?? _00_slice_1.SliceDirection.Backward, config.solver.slicer?.threshold);
         const sliceEnd = Date.now();
         if (noReconstruction) {
             results[key] = { slice: { ...slice, '.meta': { timing: sliceEnd - sliceStart } } };

package/slicing/static/fingerprint.js

@@ -7,7 +7,6 @@ exports.envFingerprint = envFingerprint;
 exports.fingerprint = fingerprint;
 const object_hash_1 = __importDefault(require("object-hash"));
 const environment_1 = require("../../dataflow/environments/environment");
-const built_in_1 = require("../../dataflow/environments/built-in");
 function envFingerprint(env) {
     return (0, object_hash_1.default)(env, {
         algorithm: 'md5',
@@ -15,7 +14,7 @@ function envFingerprint(env) {
         respectFunctionProperties: false,
         respectFunctionNames: false,
         ignoreUnknown: true,
-        replacer: (v) => (v === environment_1.BuiltInEnvironment || v === built_in_1.EmptyBuiltInMemory) ? undefined : v
+        replacer: (v) => (0, environment_1.isDefaultBuiltInEnvironment)(v) ? undefined : v
     });
 }
 function fingerprint(id, envFingerprint, onlyForSideEffects) {

package/slicing/static/slice-call.d.ts

@@ -5,11 +5,12 @@ import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexInfo } from '.
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { DataflowGraph, OutgoingEdges } from '../../dataflow/graph/graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { DataflowInformation } from '../../dataflow/info';
 /**
  * Returns the function call targets (definitions) by the given caller
  */
 export declare function getAllFunctionCallTargets(dataflowGraph: DataflowGraph, callerInfo: DataflowGraphVertexFunctionCall, baseEnvironment: REnvironmentInformation, queue: VisitingQueue): [Set<DataflowGraphVertexInfo>, REnvironmentInformation];
 /** returns the new threshold hit count */
-export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowGraph: DataflowGraph, queue: VisitingQueue): void;
+export declare function sliceForCall(current: NodeToSlice, callerInfo: DataflowGraphVertexFunctionCall, dataflowInformation: DataflowInformation, queue: VisitingQueue): void;
 /** Returns true if we found at least one return edge */
 export declare function handleReturns(from: NodeId, queue: VisitingQueue, currentEdges: OutgoingEdges, baseEnvFingerprint: Fingerprint, baseEnvironment: REnvironmentInformation): boolean;

package/slicing/static/slice-call.js

@@ -59,9 +59,9 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironm
     }
 }
 /** returns the new threshold hit count */
-function sliceForCall(current, callerInfo, dataflowGraph, queue) {
+function sliceForCall(current, callerInfo, dataflowInformation, queue) {
     const baseEnvironment = current.baseEnvironment;
-    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowGraph, callerInfo, current.baseEnvironment, queue);
+    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowInformation.graph, callerInfo, current.baseEnvironment, queue);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
     if (functionCallTargets.size === 0) {
         /*
@@ -69,7 +69,7 @@ function sliceForCall(current, callerInfo, dataflowGraph, queue) {
          * hence, we add a new flag and add all argument values to the queue causing directly
          */
         for (const arg of callerInfo.args) {
-            includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph);
+            includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowInformation.graph);
         }
         return;
     }

package/slicing/static/static-slicer.d.ts

@@ -1,24 +1,23 @@
 import type { SliceResult } from './slicer-types';
 import type { Fingerprint } from './fingerprint';
 import { VisitingQueue } from './visiting-queue';
-import type { DataflowGraph } from '../../dataflow/graph/graph';
 import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { SlicingCriteria } from '../criterion/parse';
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { SliceDirection } from '../../core/steps/all/static-slicing/00-slice';
+import type { DataflowInformation } from '../../dataflow/info';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  *
- * @param graph     - The dataflow graph to conduct the slicing on.
- * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
+ * @param info      - The dataflow information used for slicing.
  * @param criteria  - The criteria to slice on.
  * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-export declare function staticSlice(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
+export declare function staticSlice(info: DataflowInformation, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
 export declare function updatePotentialAddition(queue: VisitingQueue, id: NodeId, target: NodeId, baseEnvironment: REnvironmentInformation, envFingerprint: string): void;

package/slicing/static/static-slicer.js

@@ -20,17 +20,17 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
  *
- * @param graph     - The dataflow graph to conduct the slicing on.
- * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
+ * @param info      - The dataflow information used for slicing.
  * @param criteria  - The criteria to slice on.
  * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
-function staticSlice(graph, { idMap }, criteria, direction, threshold = 75, cache) {
+function staticSlice(info, { idMap }, criteria, direction, threshold = 75, cache) {
     (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
     const decodedCriteria = (0, parse_1.convertAllSlicingCriteriaToIds)(criteria, idMap);
     (0, log_1.expensiveTrace)(exports.slicerLogger, () => `calculating ${direction} slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
+    let { graph } = info;
     if (direction === _00_slice_1.SliceDirection.Forward) {
         graph = (0, invert_dfg_1.invertDfg)(graph);
     }
@@ -77,7 +77,7 @@ function staticSlice(graph, { idMap }, criteria, direction, threshold = 75, cach
         }
         if (!onlyForSideEffects) {
             if (currentVertex.tag === vertex_1.VertexType.FunctionCall && !currentVertex.onlyBuiltin) {
-                (0, slice_call_1.sliceForCall)(current, currentVertex, graph, queue);
+                (0, slice_call_1.sliceForCall)(current, currentVertex, info, queue);
             }
             const ret = (0, slice_call_1.handleReturns)(id, queue, currentEdges, baseEnvFingerprint, baseEnvironment);
             if (ret) {

package/util/containers.d.ts

@@ -17,6 +17,7 @@ export declare function getAccessOperands<OtherInfo>(args: readonly RFunctionArg
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
+ * @param builtInEnvironment - Built-in environment
  * @returns The indicesCollection of the resolved definitions
  */
 export declare function resolveIndicesByName(name: Identifier, environment: REnvironmentInformation): ContainerIndices[] | undefined;

package/util/containers.js

@@ -24,6 +24,7 @@ function getAccessOperands(args) {
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
+ * @param builtInEnvironment - Built-in environment
  * @returns The indicesCollection of the resolved definitions
  */
 function resolveIndicesByName(name, environment) {

package/util/json.js

@@ -46,12 +46,9 @@ function bigStringify(obj, current, send) {
     if (obj === undefined || obj === null) {
         return current + 'null';
     }
-    else if (obj === environment_1.BuiltInEnvironment) {
+    else if ((0, environment_1.isDefaultBuiltInEnvironment)(obj)) {
         return current + '<BuiltInEnvironment>';
     }
-    else if (obj === environment_1.EmptyBuiltInEnvironment) {
-        return current + '<EmptyBuiltInEnvironment>';
-    }
     else if (Array.isArray(obj)) {
         let str = current + '[';
         for (let i = 0; i < obj.length; i++) {

package/util/mermaid/dfg.js

@@ -13,7 +13,6 @@ const identifier_1 = require("../../dataflow/environments/identifier");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const edge_1 = require("../../dataflow/graph/edge");
 const vertex_1 = require("../../dataflow/graph/vertex");
-const environment_1 = require("../../dataflow/environments/environment");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
 const built_in_1 = require("../../dataflow/environments/built-in");
 /**
@@ -134,7 +133,7 @@ function printEnvironmentToLines(env) {
     if (env === undefined) {
         return ['??'];
     }
-    else if (env.id === environment_1.BuiltInEnvironment.id) {
+    else if (env.builtInEnv) {
         return ['Built-in'];
     }
     const lines = [...printEnvironmentToLines(env.parent), `${env.id}${'-'.repeat(40)}`];

package/util/prefix.d.ts

@@ -10,4 +10,4 @@
  * findByPrefixIfUnique('', { 'hello', 'hell' }) // => undefined (empty prefix)
  * ```
  */
-export declare function findByPrefixIfUnique(prefix: string, keys: readonly string[]): string | undefined;
+export declare function findByPrefixIfUnique(prefix: string, keys: readonly string[] | MapIterator<string>): string | undefined;

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.4.0';
+const version = '2.4.1';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }