@eagleoutice/flowr 2.0.6 → 2.0.8

package/benchmark/slicer.d.ts

@@ -89,7 +89,7 @@ export declare class BenchmarkSlicer {
    * @see collectAllSlicingCriteria
    * @see SlicingCriteriaFilter
    */
-    sliceForAll(filter: SlicingCriteriaFilter, report?: (current: number, total: number, allCriteria: SlicingCriteria[]) => void): Promise<number>;
+    sliceForAll(filter: SlicingCriteriaFilter, report?: (current: number, total: number, allCriteria: SlicingCriteria[]) => void, sampleRandom?: number): Promise<number>;
     /**
    * Retrieves the final stats and closes the shell session.
    * Can be called multiple times to retrieve the stored stats, but will only close the session once (the first time).

package/benchmark/slicer.js

@@ -215,10 +215,14 @@ class BenchmarkSlicer {
    * @see collectAllSlicingCriteria
    * @see SlicingCriteriaFilter
    */
-    async sliceForAll(filter, report = () => { }) {
+    async sliceForAll(filter, report = () => { }, sampleRandom = -1) {
         this.guardActive();
         let count = 0;
         const allCriteria = [...(0, collect_all_1.collectAllSlicingCriteria)(this.normalizedAst.ast, filter)];
+        if (sampleRandom > 0) {
+            allCriteria.sort(() => Math.random() - 0.5);
+            allCriteria.length = Math.min(allCriteria.length, sampleRandom);
+        }
         for (const slicingCriteria of allCriteria) {
             report(count, allCriteria.length, allCriteria);
             await this.slice(...slicingCriteria);

package/benchmark/stats/size-of.js

@@ -39,7 +39,7 @@ function getSizeOfDfGraph(df) {
                 ...vertex,
                 environment: {
                     ...vertex.environment,
-                    current: killBuiltInEnv(v.environment.current)
+                    current: killBuiltInEnv(v.environment?.current)
                 }
             };
         }

package/cli/benchmark-app.js

@@ -21,7 +21,8 @@ if (options.input.length === 0) {
     console.error('No input files given. Nothing to do. See \'--help\' if this is an error.');
     process.exit(0);
 }
-(0, assert_1.guard)(options.slice === 'all' || options.slice === 'no', 'slice must be either all or no');
+const numberRegex = /^\d+$/;
+(0, assert_1.guard)(options.slice === 'all' || options.slice === 'no' || numberRegex.test(options.slice), 'slice must be either all, no, or a number');
 (0, assert_1.guard)(options.runs === undefined || options.runs > 0, 'runs must be greater than zero');
 function removeIfExists(summarizedRaw) {
     if (fs_1.default.existsSync(summarizedRaw)) {

package/cli/benchmark-helper-app.js

@@ -20,7 +20,8 @@ const options = (0, script_1.processCommandLineArgs)('benchmark-helper', [], {
 if (options.verbose) {
     log_1.log.error('running with *verbose* setting - do not use for final benchmark', options);
 }
-(0, assert_1.guard)(options.slice === 'all' || options.slice === 'no', 'slice must be either all or no');
+const numberRegex = /^\d+$/;
+(0, assert_1.guard)(options.slice === 'all' || options.slice === 'no' || numberRegex.test(options.slice), 'slice must be either all, no, or a number');
 async function benchmark() {
     // we do not use the limit argument to be able to pick the limit randomly
     (0, assert_1.guard)(options.input !== undefined, 'No input file given');
@@ -42,9 +43,16 @@ async function benchmark() {
             console.log(`${prefix} Completed Slicing`);
             (0, assert_1.guard)(count > 0, `No possible slices found for ${options.input}, skipping in count`);
         }
-        else {
+        else if (options.slice === 'no') {
             console.log(`${prefix} Skipping Slicing due to --slice=${options.slice}`);
         }
+        else {
+            const limit = parseInt(options.slice);
+            console.log(`${prefix} Slicing up to ${limit} possible slices`);
+            const count = await slicer.sliceForAll(all_variables_1.DefaultAllVariablesFilter, (i, total, arr) => console.log(`${prefix} Slicing ${i + 1}/${total} [${JSON.stringify(arr[i])}]`), limit);
+            console.log(`${prefix} Completed Slicing`);
+            (0, assert_1.guard)(count > 0, `No possible slices found for ${options.input}, skipping in count`);
+        }
         const { stats } = slicer.finish();
         const output = {
             filename: options.input,

package/cli/common/options.js

@@ -18,7 +18,7 @@ exports.benchmarkOptions = [
     { name: 'runs', alias: 'r', type: Number, description: 'The amount of benchmark runs that should be done, out of which an average will be calculated' },
     { name: 'input', alias: 'i', type: String, description: 'Pass a folder or file as src to read from', multiple: true, defaultOption: true, defaultValue: [], typeLabel: '{underline files/folders}' },
     { name: 'parallel', alias: 'p', type: String, description: 'Number of parallel executors (defaults to {italic max(cpu.count-1, 1)})', defaultValue: Math.max(os_1.default.cpus().length - 1, 1), typeLabel: '{underline number}' },
-    { name: 'slice', alias: 's', type: String, description: 'Automatically slice for *all* variables (default) or *no* slicing and only parsing/dataflow construction', defaultValue: 'all', typeLabel: '{underline all/no}' },
+    { name: 'slice', alias: 's', type: String, description: 'Automatically slice for *all* variables (default) or *no* slicing and only parsing/dataflow construction. Numbers will indicate: sample X random slices from all.', defaultValue: 'all', typeLabel: '{underline all/no}' },
     { name: 'output', alias: 'o', type: String, description: `Directory to write all the measurements to in a per-file-basis (defaults to {italic benchmark-${StartTimeString}})`, defaultValue: `benchmark-${StartTimeString}`, typeLabel: '{underline file}' }
 ];
 exports.benchmarkHelperOptions = [
@@ -27,7 +27,7 @@ exports.benchmarkHelperOptions = [
     { name: 'input', alias: 'i', type: String, description: 'Pass a single file as src to read from', multiple: false, defaultOption: true, typeLabel: '{underline file}' },
     { name: 'file-id', alias: 'd', type: Number, description: 'A numeric file id that can be used to match an input and run-num to a file' },
     { name: 'run-num', alias: 'r', type: Number, description: 'The n-th time that the file with the given file-id is being benchmarked' },
-    { name: 'slice', alias: 's', type: String, description: 'Automatically slice for *all* variables (default) or *no* slicing and only parsing/dataflow construction', defaultValue: 'all', typeLabel: '{underline all/no}' },
+    { name: 'slice', alias: 's', type: String, description: 'Automatically slice for *all* variables (default) or *no* slicing and only parsing/dataflow construction. Numbers will indicate: sample X random slices from all.', defaultValue: 'all', typeLabel: '{underline all/no}' },
     { name: 'output', alias: 'o', type: String, description: 'File to write the measurements to (appends a single line in JSON format)', typeLabel: '{underline file}' },
 ];
 exports.exportQuadsOptions = [

package/dataflow/environments/built-in.d.ts

@@ -18,8 +18,9 @@ export interface BuiltInIdentifierConstant<T = unknown> extends IdentifierRefere
     definedAt: typeof BuiltIn;
     value: T;
 }
-export declare function registerBuiltInFunctions<Config, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(names: readonly Identifier[], processor: Proc, config: Config): void;
+export declare function registerBuiltInFunctions<Config, Proc extends BuiltInIdentifierProcessorWithConfig<Config>>(both: boolean, names: readonly Identifier[], processor: Proc, config: Config): void;
 export declare function registerReplacementFunctions(standardConfig: {
     makeMaybe?: boolean;
 }, assignments: readonly ('<-' | '<<-')[], ...prefixes: readonly Identifier[]): void;
 export declare const BuiltInMemory: Map<Identifier, IdentifierDefinition[]>;
+export declare const EmptyBuiltInMemory: Map<Identifier, IdentifierDefinition[]>;

package/dataflow/environments/built-in.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuiltInMemory = exports.registerReplacementFunctions = exports.registerBuiltInFunctions = exports.BuiltIn = void 0;
+exports.EmptyBuiltInMemory = exports.BuiltInMemory = exports.registerReplacementFunctions = exports.registerBuiltInFunctions = exports.BuiltIn = void 0;
 const known_call_handling_1 = require("../internal/process/functions/call/known-call-handling");
 const built_in_source_1 = require("../internal/process/functions/call/built-in/built-in-source");
 const built_in_access_1 = require("../internal/process/functions/call/built-in/built-in-access");
@@ -39,17 +39,21 @@ function defaultBuiltInProcessor(name, args, rootId, data, config) {
     }
     return res;
 }
-function registerBuiltInFunctions(names, processor, config) {
+function registerBuiltInFunctions(both, names, processor, config) {
     for (const name of names) {
         (0, assert_1.guard)(!exports.BuiltInMemory.has(name), `Built-in ${name} already defined`);
-        exports.BuiltInMemory.set(name, [{
+        const d = [{
                 kind: 'built-in-function',
                 definedAt: exports.BuiltIn,
                 controlDependencies: undefined,
                 processor: (name, args, rootId, data) => processor(name, args, rootId, data, config),
                 name,
                 nodeId: exports.BuiltIn
-            }]);
+            }];
+        exports.BuiltInMemory.set(name, d);
+        if (both) {
+            exports.EmptyBuiltInMemory.set(name, d);
+        }
     }
 }
 exports.registerBuiltInFunctions = registerBuiltInFunctions;
@@ -72,53 +76,58 @@ function registerReplacementFunctions(standardConfig, assignments, ...prefixes)
 }
 exports.registerReplacementFunctions = registerReplacementFunctions;
 function registerSimpleFunctions(...names) {
-    registerBuiltInFunctions(names, defaultBuiltInProcessor, { readAllArguments: true });
+    registerBuiltInFunctions(false, names, defaultBuiltInProcessor, { readAllArguments: true });
 }
-function registerBuiltInConstant(name, value) {
+function registerBuiltInConstant(both, name, value) {
     (0, assert_1.guard)(!exports.BuiltInMemory.has(name), `Built-in ${name} already defined`);
-    exports.BuiltInMemory.set(name, [{
+    const d = [{
             kind: 'built-in-value',
             definedAt: exports.BuiltIn,
             controlDependencies: undefined,
             value,
             name,
             nodeId: exports.BuiltIn
-        }]);
+        }];
+    exports.BuiltInMemory.set(name, d);
+    if (both) {
+        exports.EmptyBuiltInMemory.set(name, d);
+    }
 }
 exports.BuiltInMemory = new Map();
-registerBuiltInConstant('NULL', null);
-registerBuiltInConstant('NA', null);
-registerBuiltInConstant('TRUE', true);
-registerBuiltInConstant('T', true);
-registerBuiltInConstant('FALSE', false);
-registerBuiltInConstant('F', false);
-registerSimpleFunctions('~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', ':', 'list');
-registerBuiltInFunctions(['cat', 'switch'], defaultBuiltInProcessor, {}); /* returns null */
-registerBuiltInFunctions(['print', '('], defaultBuiltInProcessor, { returnsNthArgument: 0 });
-registerBuiltInFunctions(['return'], defaultBuiltInProcessor, { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ });
-registerBuiltInFunctions(['break'], defaultBuiltInProcessor, { cfg: 2 /* ExitPointType.Break */ });
-registerBuiltInFunctions(['next'], defaultBuiltInProcessor, { cfg: 3 /* ExitPointType.Next */ });
-registerBuiltInFunctions(['{'], built_in_expression_list_1.processExpressionList, {});
-registerBuiltInFunctions(['source'], built_in_source_1.processSourceCall, {});
-registerBuiltInFunctions(['[', '[['], built_in_access_1.processAccess, { treatIndicesAsString: false });
-registerBuiltInFunctions(['$', '@'], built_in_access_1.processAccess, { treatIndicesAsString: true });
-registerBuiltInFunctions(['if'], built_in_if_then_else_1.processIfThenElse, {});
-registerBuiltInFunctions(['get'], built_in_get_1.processGet, {});
-registerBuiltInFunctions(['library'], built_in_library_1.processLibrary, {});
-registerBuiltInFunctions(['<-', '='], built_in_assignment_1.processAssignment, { canBeReplacement: true });
-registerBuiltInFunctions([':=', 'assign'], built_in_assignment_1.processAssignment, {});
-registerBuiltInFunctions(['delayedAssign'], built_in_assignment_1.processAssignment, { quoteSource: true });
-registerBuiltInFunctions(['<<-'], built_in_assignment_1.processAssignment, { superAssignment: true, canBeReplacement: true });
-registerBuiltInFunctions(['->'], built_in_assignment_1.processAssignment, { swapSourceAndTarget: true, canBeReplacement: true });
-registerBuiltInFunctions(['->>'], built_in_assignment_1.processAssignment, { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true });
-registerBuiltInFunctions(['&&', '&'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: true });
-registerBuiltInFunctions(['||', '|'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: false });
-registerBuiltInFunctions(['|>', '%>%'], built_in_pipe_1.processPipe, {});
-registerBuiltInFunctions(['function', '\\'], built_in_function_definition_1.processFunctionDefinition, {});
-registerBuiltInFunctions(['quote', 'substitute', 'bquote'], built_in_quote_1.processQuote, { quoteArgumentsWithIndex: 0 });
-registerBuiltInFunctions(['for'], built_in_for_loop_1.processForLoop, {});
-registerBuiltInFunctions(['repeat'], built_in_repeat_loop_1.processRepeatLoop, {});
-registerBuiltInFunctions(['while'], built_in_while_loop_1.processWhileLoop, {});
+exports.EmptyBuiltInMemory = new Map();
+registerBuiltInConstant(true, 'NULL', null);
+registerBuiltInConstant(true, 'NA', null);
+registerBuiltInConstant(true, 'TRUE', true);
+registerBuiltInConstant(true, 'T', true);
+registerBuiltInConstant(true, 'FALSE', false);
+registerBuiltInConstant(true, 'F', false);
+registerSimpleFunctions('~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list', 'c', 'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max', 'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean', 'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'plot', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix', 'apply', 'lapply', 'sapply', 'tapply', 'mapply', 'do.call', 'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor', 'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar', 't');
+registerBuiltInFunctions(true, ['print', '('], defaultBuiltInProcessor, { returnsNthArgument: 0 });
+registerBuiltInFunctions(false, ['cat', 'switch'], defaultBuiltInProcessor, {}); /* returns null */
+registerBuiltInFunctions(true, ['return'], defaultBuiltInProcessor, { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ });
+registerBuiltInFunctions(true, ['break'], defaultBuiltInProcessor, { cfg: 2 /* ExitPointType.Break */ });
+registerBuiltInFunctions(true, ['next'], defaultBuiltInProcessor, { cfg: 3 /* ExitPointType.Next */ });
+registerBuiltInFunctions(true, ['{'], built_in_expression_list_1.processExpressionList, {});
+registerBuiltInFunctions(true, ['source'], built_in_source_1.processSourceCall, {});
+registerBuiltInFunctions(true, ['[', '[['], built_in_access_1.processAccess, { treatIndicesAsString: false });
+registerBuiltInFunctions(true, ['$', '@'], built_in_access_1.processAccess, { treatIndicesAsString: true });
+registerBuiltInFunctions(true, ['if', 'ifelse'], built_in_if_then_else_1.processIfThenElse, {});
+registerBuiltInFunctions(true, ['get'], built_in_get_1.processGet, {});
+registerBuiltInFunctions(false, ['library'], built_in_library_1.processLibrary, {});
+registerBuiltInFunctions(true, ['<-', '='], built_in_assignment_1.processAssignment, { canBeReplacement: true });
+registerBuiltInFunctions(true, [':=', 'assign'], built_in_assignment_1.processAssignment, {});
+registerBuiltInFunctions(true, ['delayedAssign'], built_in_assignment_1.processAssignment, { quoteSource: true });
+registerBuiltInFunctions(true, ['<<-'], built_in_assignment_1.processAssignment, { superAssignment: true, canBeReplacement: true });
+registerBuiltInFunctions(true, ['->'], built_in_assignment_1.processAssignment, { swapSourceAndTarget: true, canBeReplacement: true });
+registerBuiltInFunctions(true, ['->>'], built_in_assignment_1.processAssignment, { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true });
+registerBuiltInFunctions(true, ['&&', '&'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: true });
+registerBuiltInFunctions(true, ['||', '|'], built_in_logical_bin_op_1.processSpecialBinOp, { lazy: true, evalRhsWhen: false });
+registerBuiltInFunctions(true, ['|>', '%>%'], built_in_pipe_1.processPipe, {});
+registerBuiltInFunctions(true, ['function', '\\'], built_in_function_definition_1.processFunctionDefinition, {});
+registerBuiltInFunctions(true, ['quote', 'substitute', 'bquote'], built_in_quote_1.processQuote, { quoteArgumentsWithIndex: 0 });
+registerBuiltInFunctions(true, ['for'], built_in_for_loop_1.processForLoop, {});
+registerBuiltInFunctions(true, ['repeat'], built_in_repeat_loop_1.processRepeatLoop, {});
+registerBuiltInFunctions(true, ['while'], built_in_while_loop_1.processWhileLoop, {});
 /* they are all mapped to `<-` but we separate super assignments */
 registerReplacementFunctions({ makeMaybe: true }, ['<-', '<<-'], '[', '[[', '$', '@', 'names', 'dimnames', 'attributes', 'attr', 'class', 'levels', 'rownames', 'colnames');
 //# sourceMappingURL=built-in.js.map

package/dataflow/environments/diff.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.diffEnvironmentInformation = exports.diffEnvironment = exports.diffIdentifierReferences = void 0;
 const diff_1 = require("../../util/diff");
+const environment_1 = require("./environment");
 const json_1 = require("../../util/json");
 const info_1 = require("../info");
+const built_in_1 = require("./built-in");
 function diffIdentifierReferences(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -56,6 +58,10 @@ function diffEnvironment(a, b, info, depth) {
         }
         return;
     }
+    if ((a.memory === built_in_1.BuiltInMemory || a.memory === built_in_1.EmptyBuiltInMemory) &&
+        (b.memory === built_in_1.BuiltInMemory || b.memory === built_in_1.EmptyBuiltInMemory)) {
+        return;
+    }
     if (a.memory.size !== b.memory.size) {
         info.report.addComment(`${info.position}[at level: ${depth}] Different number of definitions in environment. ${info.leftname}: ${a.memory.size} vs. ${info.rightname}: ${b.memory.size}`);
         (0, diff_1.setDifference)(new Set([...a.memory.keys()]), new Set([...b.memory.keys()]), {
@@ -70,7 +76,7 @@ exports.diffEnvironment = diffEnvironment;
 function diffEnvironmentInformation(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
-            info.report.addComment(`${info.position}Different environments: ${JSON.stringify(a, json_1.jsonReplacer)} vs. ${JSON.stringify(b, json_1.jsonReplacer)}`);
+            info.report.addComment(`${info.position}Different environments: ${JSON.stringify(a, environment_1.builtInEnvJsonReplacer)} vs. ${JSON.stringify(b, environment_1.builtInEnvJsonReplacer)}`);
         }
         return;
     }

package/dataflow/environments/environment.d.ts

@@ -40,4 +40,5 @@ export interface REnvironmentInformation {
     readonly level: number;
 }
 export declare const BuiltInEnvironment: Environment;
-export declare function initializeCleanEnvironments(): REnvironmentInformation;
+export declare function initializeCleanEnvironments(fullBuiltIns?: boolean): REnvironmentInformation;
+export declare function builtInEnvJsonReplacer(k: unknown, v: unknown): unknown;

package/dataflow/environments/environment.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeCleanEnvironments = exports.BuiltInEnvironment = exports.Environment = exports.makeAllMaybe = exports.makeReferenceMaybe = void 0;
+exports.builtInEnvJsonReplacer = exports.initializeCleanEnvironments = exports.BuiltInEnvironment = exports.Environment = exports.makeAllMaybe = exports.makeReferenceMaybe = void 0;
 const built_in_1 = require("./built-in");
 const resolve_by_name_1 = require("./resolve-by-name");
+const json_1 = require("../../util/json");
 function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = undefined) {
     const node = graph.get(ref.nodeId, true);
     if (includeDefs) {
@@ -49,12 +50,31 @@ class Environment {
 exports.Environment = Environment;
 /* the built-in environment is the root of all environments */
 exports.BuiltInEnvironment = new Environment(undefined);
-exports.BuiltInEnvironment.memory = built_in_1.BuiltInMemory;
-function initializeCleanEnvironments() {
+exports.BuiltInEnvironment.memory = undefined;
+const EmptyBuiltInEnvironment = {
+    id: exports.BuiltInEnvironment.id,
+    memory: undefined,
+    parent: undefined
+};
+function initializeCleanEnvironments(fullBuiltIns = true) {
+    exports.BuiltInEnvironment.memory ??= built_in_1.BuiltInMemory;
+    EmptyBuiltInEnvironment.memory ??= built_in_1.EmptyBuiltInMemory;
     return {
-        current: new Environment(exports.BuiltInEnvironment),
+        current: new Environment(fullBuiltIns ? exports.BuiltInEnvironment : EmptyBuiltInEnvironment),
         level: 0
     };
 }
 exports.initializeCleanEnvironments = initializeCleanEnvironments;
+function builtInEnvJsonReplacer(k, v) {
+    if (v === exports.BuiltInEnvironment) {
+        return '<BuiltInEnvironment>';
+    }
+    else if (v === EmptyBuiltInEnvironment) {
+        return '<EmptyBuiltInEnvironment>';
+    }
+    else {
+        return (0, json_1.jsonReplacer)(k, v);
+    }
+}
+exports.builtInEnvJsonReplacer = builtInEnvJsonReplacer;
 //# sourceMappingURL=environment.js.map

package/dataflow/graph/edge.js

@@ -62,8 +62,9 @@ function edgeDoesNotIncludeType(type, types) {
     return (types & type) === 0;
 }
 exports.edgeDoesNotIncludeType = edgeDoesNotIncludeType;
+const alwaysTraverseEdgeTypes = 1 /* EdgeType.Reads */ | 2 /* EdgeType.DefinedBy */ | 64 /* EdgeType.Argument */ | 4 /* EdgeType.Calls */ | 16 /* EdgeType.DefinesOnCall */;
 function shouldTraverseEdge(types) {
-    if (edgeIncludesType(types, 1 /* EdgeType.Reads */ | 2 /* EdgeType.DefinedBy */ | 64 /* EdgeType.Argument */ | 4 /* EdgeType.Calls */ | 16 /* EdgeType.DefinesOnCall */)) {
+    if (edgeIncludesType(types, alwaysTraverseEdgeTypes)) {
         return 3 /* TraverseEdge.Always */;
     }
     else if (edgeIncludesType(types, 32 /* EdgeType.DefinedByOnCall */)) {

package/dataflow/graph/graph.d.ts

@@ -47,6 +47,7 @@ type EdgeData<Edge extends DataflowGraphEdge> = Omit<Edge, 'from' | 'to' | 'type
 export declare class DataflowGraph<Vertex extends DataflowGraphVertexInfo = DataflowGraphVertexInfo, Edge extends DataflowGraphEdge = DataflowGraphEdge> {
     private static DEFAULT_ENVIRONMENT;
     private _idMap;
+    readonly functionCache: Map<NodeId, Set<DataflowGraphVertexInfo>>;
     constructor(idMap: AstIdMap | undefined);
     /** Contains the vertices of the root level graph (i.e., included those vertices from the complete graph, that are nested within function definitions) */
     private rootVertices;

package/dataflow/graph/graph.js

@@ -42,6 +42,8 @@ function extractEdgeIds(from, to) {
 class DataflowGraph {
     static DEFAULT_ENVIRONMENT = undefined;
     _idMap;
+    // this should be linked separately
+    functionCache = new Map();
     constructor(idMap) {
         DataflowGraph.DEFAULT_ENVIRONMENT ??= (0, environment_1.initializeCleanEnvironments)();
         this._idMap = idMap;
@@ -155,7 +157,7 @@ class DataflowGraph {
         if (oldVertex !== undefined) {
             return this;
         }
-        const fallback = vertex.tag === "variable-definition" /* VertexType.VariableDefinition */ || vertex.tag === "use" /* VertexType.Use */ || vertex.tag === "value" /* VertexType.Value */ ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
+        const fallback = vertex.tag === "variable-definition" /* VertexType.VariableDefinition */ || vertex.tag === "use" /* VertexType.Use */ || vertex.tag === "value" /* VertexType.Value */ || (vertex.tag === "function-call" /* VertexType.FunctionCall */ && vertex.onlyBuiltin) ? undefined : DataflowGraph.DEFAULT_ENVIRONMENT;
         // keep a clone of the original environment
         const environment = vertex.environment === undefined ? fallback : (0, clone_1.cloneEnvironmentInformation)(vertex.environment);
         this.vertexInformation.set(vertex.id, {

package/dataflow/graph/vertex.d.ts

@@ -62,7 +62,7 @@ export interface DataflowGraphVertexFunctionCall extends DataflowGraphVertexBase
     args: FunctionArgument[];
     /** a performance flag to indicate that the respective call is _only_ calling a builtin function without any df graph attached */
     onlyBuiltin: boolean;
-    readonly environment: REnvironmentInformation;
+    environment: REnvironmentInformation | undefined;
 }
 /**
  * Arguments required to construct a vertex which represents the definition of a variable in the dataflow graph.

package/dataflow/internal/linker.d.ts

@@ -17,7 +17,7 @@ export declare function linkFunctionCalls(graph: DataflowGraph, idMap: AstIdMap,
     functionCall: NodeId;
     called: readonly DataflowGraphVertexInfo[];
 }[];
-export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): Map<NodeId, DataflowGraphVertexInfo>;
+export declare function getAllLinkedFunctionDefinitions(functionDefinitionReadIds: ReadonlySet<NodeId>, dataflowGraph: DataflowGraph): Set<DataflowGraphVertexInfo>;
 /**
  * This method links a set of read variables to definitions in an environment.
  *

package/dataflow/internal/linker.js

@@ -133,7 +133,7 @@ exports.linkFunctionCalls = linkFunctionCalls;
 function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGraph) {
     const potential = [...functionDefinitionReadIds];
     const visited = new Set();
-    const result = new Map();
+    const result = new Set();
     while (potential.length > 0) {
         const currentId = potential.pop();
         // do not traverse builtins
@@ -156,7 +156,7 @@ function getAllLinkedFunctionDefinitions(functionDefinitionReadIds, dataflowGrap
         const followBits = 1 /* EdgeType.Reads */ | 2 /* EdgeType.DefinedBy */ | 32 /* EdgeType.DefinedByOnCall */;
         const followEdges = outgoingEdges.filter(([_, e]) => (0, edge_1.edgeIncludesType)(e.types, followBits));
         if (currentInfo[0].subflow !== undefined) {
-            result.set(currentId, currentInfo[0]);
+            result.add(currentInfo[0]);
         }
         // trace all joined reads
         potential.push(...followEdges.map(([target]) => target).filter(id => !visited.has(id)));

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

@@ -38,7 +38,7 @@ function processForLoop(name, args, rootId, data) {
     }
     data = { ...data, environment: headEnvironments };
     /* process the body without any environment first, to retrieve all open references */
-    let environment = (0, environment_1.initializeCleanEnvironments)();
+    let environment = (0, environment_1.initializeCleanEnvironments)(false);
     while (headEnvironments.level > environment.level) {
         environment = (0, scoping_1.pushLocalEnvironment)(environment);
     }

package/dataflow/internal/process/functions/call/common.js

@@ -58,7 +58,7 @@ function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResul
         /* will be overwritten accordingly */
         onlyBuiltin: false,
         controlDependencies: data.controlDependencies,
-        args: argumentProcessResult.map(arg => arg === undefined ? r_function_call_1.EmptyArgument : { nodeId: arg.entryPoint, controlDependencies: undefined })
+        args: argumentProcessResult.map(arg => arg === undefined ? r_function_call_1.EmptyArgument : { nodeId: arg.entryPoint, controlDependencies: undefined, call: undefined })
     });
     for (const arg of argumentProcessResult) {
         if (arg) {

package/dataflow/internal/process/functions/call/known-call-handling.js

@@ -41,7 +41,7 @@ function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = fal
         args: reverseOrder ? [...callArgs].reverse() : callArgs
     });
     const inIds = remainingReadInArgs;
-    const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies };
+    const fnRef = { nodeId: rootId, name: functionCallName, controlDependencies: data.controlDependencies, call: true };
     inIds.push(fnRef);
     return {
         information: {

package/dataflow/internal/process/functions/call/named-call-handling.js

@@ -45,6 +45,7 @@ function processNamedCall(name, args, rootId, data) {
         const v = information.graph.getVertex(rootId);
         if (v?.tag === "function-call" /* VertexType.FunctionCall */) {
             v.onlyBuiltin = true;
+            v.environment = undefined;
         }
     }
     return information ?? (0, info_1.initializeCleanDataflowInformation)(rootId, data);

package/package.json

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

package/slicing/static/fingerprint.js

@@ -6,8 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fingerprint = exports.envFingerprint = void 0;
 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, { excludeKeys: key => key === 'id', replacer: (v) => v === environment_1.BuiltInEnvironment ? undefined : v });
+    return (0, object_hash_1.default)(env, { excludeKeys: key => key === 'id', replacer: (v) => (v === environment_1.BuiltInEnvironment || v === built_in_1.EmptyBuiltInMemory) ? undefined : v });
 }
 exports.envFingerprint = envFingerprint;
 function fingerprint(id, envFingerprint, onlyForSideEffects) {

package/slicing/static/slice-call.js

@@ -4,6 +4,7 @@ exports.handleReturns = exports.sliceForCall = void 0;
 const assert_1 = require("../../util/assert");
 const fingerprint_1 = require("./fingerprint");
 const linker_1 = require("../../dataflow/internal/linker");
+const environment_1 = require("../../dataflow/environments/environment");
 const scoping_1 = require("../../dataflow/environments/scoping");
 const overwrite_1 = require("../../dataflow/environments/overwrite");
 const built_in_1 = require("../../dataflow/environments/built-in");
@@ -11,12 +12,13 @@ const resolve_by_name_1 = require("../../dataflow/environments/resolve-by-name")
 const edge_1 = require("../../dataflow/graph/edge");
 function retrieveActiveEnvironment(callerInfo, baseEnvironment) {
     let callerEnvironment = callerInfo.environment;
-    if (baseEnvironment.level !== callerEnvironment.level) {
-        while (baseEnvironment.level < callerEnvironment.level) {
+    const level = callerEnvironment?.level ?? 0;
+    if (baseEnvironment.level !== level) {
+        while (baseEnvironment.level < level) {
             baseEnvironment = (0, scoping_1.pushLocalEnvironment)(baseEnvironment);
         }
-        while (baseEnvironment.level > callerEnvironment.level) {
-            callerEnvironment = (0, scoping_1.pushLocalEnvironment)(callerEnvironment);
+        while (baseEnvironment.level > level) {
+            callerEnvironment = (0, scoping_1.pushLocalEnvironment)(callerEnvironment ?? (0, environment_1.initializeCleanEnvironments)(true));
         }
     }
     return (0, overwrite_1.overwriteEnvironment)(baseEnvironment, callerEnvironment);
@@ -40,7 +42,7 @@ function sliceForCall(current, callerInfo, dataflowGraph, queue) {
         }
     }
     const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
-    for (const [_, functionCallTarget] of functionCallTargets) {
+    for (const functionCallTarget of functionCallTargets) {
         // all those linked within the scopes of other functions are already linked when exiting a function definition
         for (const openIn of functionCallTarget.subflow.in) {
             const defs = openIn.name ? (0, resolve_by_name_1.resolveByName)(openIn.name, activeEnvironment) : undefined;
@@ -59,25 +61,24 @@ function sliceForCall(current, callerInfo, dataflowGraph, queue) {
 exports.sliceForCall = sliceForCall;
 /** Returns true if we found at least one return edge */
 function handleReturns(queue, currentEdges, baseEnvFingerprint, baseEnvironment) {
-    let found = false;
-    for (const [, edge] of currentEdges) {
-        if ((0, edge_1.edgeIncludesType)(edge.types, 8 /* EdgeType.Returns */)) {
-            found = true;
-            break;
-        }
-    }
-    if (!found) {
+    const e = [...currentEdges.entries()];
+    const found = e.filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, 8 /* EdgeType.Returns */));
+    if (found.length === 0) {
         return false;
     }
-    for (const [target, edge] of currentEdges) {
-        if ((0, edge_1.edgeIncludesType)(edge.types, 8 /* EdgeType.Returns */)) {
-            queue.add(target, baseEnvironment, baseEnvFingerprint, false);
-        }
-        else if ((0, edge_1.edgeIncludesType)(edge.types, 1 /* EdgeType.Reads */)) {
+    for (const [target,] of found) {
+        queue.add(target, baseEnvironment, baseEnvFingerprint, false);
+    }
+    for (const [target, edge] of e) {
+        if ((0, edge_1.edgeIncludesType)(edge.types, 1 /* EdgeType.Reads */)) {
             queue.add(target, baseEnvironment, baseEnvFingerprint, false);
         }
         else if ((0, edge_1.edgeIncludesType)(edge.types, 64 /* EdgeType.Argument */)) {
-            queue.potentialArguments.add(target);
+            queue.potentialArguments.set(target, {
+                id: target,
+                baseEnvironment,
+                onlyForSideEffects: false
+            });
         }
     }
     return true;

package/slicing/static/static-slicer.js

@@ -9,7 +9,6 @@ const slice_call_1 = require("./slice-call");
 const parse_1 = require("../criterion/parse");
 const environment_1 = require("../../dataflow/environments/environment");
 const edge_1 = require("../../dataflow/graph/edge");
-const built_in_1 = require("../../dataflow/environments/built-in");
 exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
 /**
  * This returns the ids to include in the slice, when slicing with the given seed id's (must be at least one).
@@ -45,9 +44,9 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
         }
         const [currentVertex, currentEdges] = currentInfo;
         // we only add control dependencies iff 1) we are in different function call or 2) they have, at least, the same depth as the slicing seed
-        if (currentVertex.controlDependencies) {
+        if (currentVertex.controlDependencies && currentVertex.controlDependencies.length > 0) {
             const topLevel = graph.isRoot(id) || sliceSeedIds.has(id);
-            for (const cd of currentVertex.controlDependencies) {
+            for (const cd of currentVertex.controlDependencies.filter(({ id }) => !queue.hasId(id))) {
                 if (!topLevel || (ast.idMap.get(cd.id)?.info.depth ?? 0) <= minDepth) {
                     queue.add(cd.id, baseEnvironment, baseEnvFingerprint, false);
                 }
@@ -63,16 +62,19 @@ function staticSlicing(graph, ast, criteria, threshold = 75) {
             }
         }
         for (const [target, { types }] of currentEdges) {
-            if (target === built_in_1.BuiltIn || (0, edge_1.edgeIncludesType)(types, 256 /* EdgeType.NonStandardEvaluation */)) {
+            if ((0, edge_1.edgeIncludesType)(types, 256 /* EdgeType.NonStandardEvaluation */)) {
                 continue;
             }
             const t = (0, edge_1.shouldTraverseEdge)(types);
             if (t === 3 /* TraverseEdge.Always */) {
                 queue.add(target, baseEnvironment, baseEnvFingerprint, false);
             }
-            else if (t === 2 /* TraverseEdge.DefinedByOnCall */ && queue.potentialArguments.has(target)) {
-                queue.add(target, baseEnvironment, baseEnvFingerprint, false);
-                queue.potentialArguments.delete(target);
+            else if (t === 2 /* TraverseEdge.DefinedByOnCall */) {
+                const n = queue.potentialArguments.get(target);
+                if (n) {
+                    queue.add(target, n.baseEnvironment, (0, fingerprint_1.envFingerprint)(n.baseEnvironment), n.onlyForSideEffects);
+                    queue.potentialArguments.delete(target);
+                }
             }
             else if (t === 1 /* TraverseEdge.SideEffect */) {
                 queue.add(target, baseEnvironment, baseEnvFingerprint, true);

package/slicing/static/visiting-queue.d.ts

@@ -7,7 +7,7 @@ export declare class VisitingQueue {
     private seen;
     private idThreshold;
     private queue;
-    potentialArguments: Set<NodeId>;
+    potentialArguments: Map<NodeId, NodeToSlice>;
     constructor(threshold: number);
     /**
      * Adds a node to the queue if it has not been seen before.
@@ -19,5 +19,6 @@ export declare class VisitingQueue {
     add(target: NodeId, env: REnvironmentInformation, envFingerprint: string, onlyForSideEffects: boolean): void;
     next(): NodeToSlice;
     nonEmpty(): boolean;
+    hasId(id: NodeId): boolean;
     status(): Readonly<Pick<SliceResult, 'timesHitThreshold' | 'result'>>;
 }

package/slicing/static/visiting-queue.js

@@ -10,7 +10,7 @@ class VisitingQueue {
     idThreshold = new Map();
     queue = [];
     // the set of potential arguments holds arguments which may be added if found with the `defined-by-on-call` edge
-    potentialArguments = new Set();
+    potentialArguments = new Map();
     constructor(threshold) {
         this.threshold = threshold;
     }
@@ -42,6 +42,9 @@ class VisitingQueue {
     nonEmpty() {
         return this.queue.length > 0;
     }
+    hasId(id) {
+        return this.idThreshold.has(id);
+    }
     status() {
         return {
             timesHitThreshold: this.timesHitThreshold,

package/util/mermaid/dfg.js

@@ -57,11 +57,11 @@ function printArg(arg) {
         return '[empty]';
     }
     else if ((0, graph_1.isNamedArgument)(arg)) {
-        const deps = arg.controlDependencies ? ', :maybe:' + arg.controlDependencies.join(',') : '';
+        const deps = arg.controlDependencies ? ', :maybe:' + arg.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') : '';
         return `${arg.name} (${arg.nodeId}${deps})`;
     }
     else if ((0, graph_1.isPositionalArgument)(arg)) {
-        const deps = arg.controlDependencies ? ' (:maybe:' + arg.controlDependencies.join(',') + ')' : '';
+        const deps = arg.controlDependencies ? ' (:maybe:' + arg.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') + ')' : '';
         return `${arg.nodeId}${deps}`;
     }
     else {
@@ -100,7 +100,7 @@ function mermaidNodeBrackets(tag) {
     return { open, close };
 }
 function printIdentifier(id) {
-    return `${id.name} (${id.nodeId}, ${id.kind},${id.controlDependencies ? ' {' + id.controlDependencies.join(',') + '},' : ''} def. @${id.definedAt})`;
+    return `${id.name} (${id.nodeId}, ${id.kind},${id.controlDependencies ? ' {' + id.controlDependencies.map(c => c.id + (c.when ? '+' : '-')).join(',') + '},' : ''} def. @${id.definedAt})`;
 }
 function printEnvironmentToLines(env) {
     if (env === undefined) {

package/util/version.js

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