@eagleoutice/flowr 2.0.6 → 2.0.7

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/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

@@ -4,6 +4,7 @@ exports.diffEnvironmentInformation = exports.diffEnvironment = exports.diffIdent
 const diff_1 = require("../../util/diff");
 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 +57,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()]), {

package/dataflow/environments/environment.d.ts

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

package/dataflow/environments/environment.js

@@ -49,10 +49,17 @@ 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
     };
 }

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "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

@@ -59,21 +59,16 @@ 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 */)) {

package/slicing/static/static-slicer.js

@@ -45,9 +45,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);
                 }

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

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

@@ -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.7';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }