@eagleoutice/flowr 2.6.3 → 2.7.0

package/benchmark/summarizer/first-phase/process.js

@@ -266,26 +266,29 @@ function summarizeDfShapeStats({ perNodeStats, ...stats }) {
         numberOfEntriesPerNode: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.numberOfEntries)),
         numberOfOperations: (0, arrays_1.arraySum)(nodeStats.map(s => s.mappedOperations?.length).filter(assert_1.isNotUndefined)),
         numberOfTotalValues: nodeStats.filter(s => isValue(s.inferredColNames) && isValue(s.inferredColCount) && isValue(s.inferredRowCount)).length,
-        numberOfTotalTop: nodeStats.filter(s => isTop(s.inferredColNames) && isTop(s.inferredColCount) && isTop(s.inferredRowCount)).length,
         numberOfTotalBottom: nodeStats.filter(s => s.inferredColNames === 0 && isBottom(s.inferredColCount) && isBottom(s.inferredRowCount)).length,
+        numberOfTotalTop: nodeStats.filter(s => isTop(s.inferredColNames) && isTop(s.inferredColCount) && isTop(s.inferredRowCount)).length,
         inferredColNames: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.inferredColNames).filter(isValue)),
+        approxRangeColNames: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.approxRangeColNames).filter(assert_1.isNotUndefined).filter(isFinite)),
+        numberOfColNamesExact: nodeStats.map(s => s.approxRangeColNames).filter(range => range === 0).length,
         numberOfColNamesValues: nodeStats.map(s => s.inferredColNames).filter(isValue).length,
+        numberOfColNamesBottom: nodeStats.map(s => s.inferredColNames).filter(isBottom).length,
+        numberOfColNamesInfinite: nodeStats.map(s => s.inferredColNames).filter(isInfinite).length,
         numberOfColNamesTop: nodeStats.map(s => s.inferredColNames).filter(isTop).length,
-        numberOfColNamesBottom: nodeStats.map(s => s.inferredColNames).filter(number => number === 0).length,
         inferredColCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.inferredColCount).filter(isValue)),
+        approxRangeColCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.approxRangeColCount).filter(assert_1.isNotUndefined).filter(isFinite)),
         numberOfColCountExact: nodeStats.map(s => s.approxRangeColCount).filter(range => range === 0).length,
         numberOfColCountValues: nodeStats.map(s => s.inferredColCount).filter(isValue).length,
-        numberOfColCountTop: nodeStats.map(s => s.inferredColCount).filter(isTop).length,
-        numberOfColCountInfinite: nodeStats.map(s => s.inferredColCount).filter(isInfinite).length,
         numberOfColCountBottom: nodeStats.map(s => s.inferredColCount).filter(isBottom).length,
-        approxRangeColCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.approxRangeColCount).filter(assert_1.isNotUndefined).filter(isFinite)),
+        numberOfColCountInfinite: nodeStats.map(s => s.inferredColCount).filter(isInfinite).length,
+        numberOfColCountTop: nodeStats.map(s => s.inferredColCount).filter(isTop).length,
         inferredRowCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.inferredRowCount).filter(isValue)),
+        approxRangeRowCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.approxRangeRowCount).filter(assert_1.isNotUndefined).filter(isFinite)),
         numberOfRowCountExact: nodeStats.map(s => s.approxRangeRowCount).filter(range => range === 0).length,
         numberOfRowCountValues: nodeStats.map(s => s.inferredRowCount).filter(isValue).length,
-        numberOfRowCountTop: nodeStats.map(s => s.inferredRowCount).filter(isTop).length,
-        numberOfRowCountInfinite: nodeStats.map(s => s.inferredRowCount).filter(isInfinite).length,
         numberOfRowCountBottom: nodeStats.map(s => s.inferredRowCount).filter(isBottom).length,
-        approxRangeRowCount: (0, summarizer_1.summarizeMeasurement)(nodeStats.map(s => s.approxRangeRowCount).filter(assert_1.isNotUndefined).filter(isFinite)),
+        numberOfRowCountInfinite: nodeStats.map(s => s.inferredRowCount).filter(isInfinite).length,
+        numberOfRowCountTop: nodeStats.map(s => s.inferredRowCount).filter(isTop).length,
         perOperationNumber: summarizePerOperationStats(nodeStats),
     };
 }

package/benchmark/summarizer/second-phase/process.js

@@ -114,8 +114,8 @@ function summarizeAllSummarizedStats(stats) {
             numberOfNonDataFrameFiles: (0, arrays_1.arraySum)(stats.map(s => s.dataFrameShape?.numberOfNonDataFrameFiles).filter(assert_1.isNotUndefined)),
             numberOfResultConstraints: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultConstraints).filter(assert_1.isNotUndefined)),
             numberOfResultingValues: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingValues).filter(assert_1.isNotUndefined)),
-            numberOfResultingTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingTop).filter(assert_1.isNotUndefined)),
             numberOfResultingBottom: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingBottom).filter(assert_1.isNotUndefined)),
+            numberOfResultingTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingTop).filter(assert_1.isNotUndefined)),
             numberOfEmptyNodes: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfEmptyNodes).filter(assert_1.isNotUndefined)),
             numberOfOperationNodes: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfOperationNodes).filter(assert_1.isNotUndefined)),
             numberOfValueNodes: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfValueNodes).filter(assert_1.isNotUndefined)),
@@ -123,26 +123,29 @@ function summarizeAllSummarizedStats(stats) {
             numberOfEntriesPerNode: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfEntriesPerNode).filter(assert_1.isNotUndefined)),
             numberOfOperations: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfOperations).filter(assert_1.isNotUndefined)),
             numberOfTotalValues: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalValues).filter(assert_1.isNotUndefined)),
-            numberOfTotalTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalTop).filter(assert_1.isNotUndefined)),
             numberOfTotalBottom: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalBottom).filter(assert_1.isNotUndefined)),
+            numberOfTotalTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalTop).filter(assert_1.isNotUndefined)),
             inferredColNames: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.inferredColNames).filter(assert_1.isNotUndefined)),
+            approxRangeColNames: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeColNames).filter(assert_1.isNotUndefined)),
+            numberOfColNamesExact: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesExact).filter(assert_1.isNotUndefined)),
             numberOfColNamesValues: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesValues).filter(assert_1.isNotUndefined)),
-            numberOfColNamesTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesTop).filter(assert_1.isNotUndefined)),
             numberOfColNamesBottom: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesBottom).filter(assert_1.isNotUndefined)),
+            numberOfColNamesInfinite: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesInfinite).filter(assert_1.isNotUndefined)),
+            numberOfColNamesTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesTop).filter(assert_1.isNotUndefined)),
             inferredColCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.inferredColCount).filter(assert_1.isNotUndefined)),
+            approxRangeColCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeColCount).filter(assert_1.isNotUndefined)),
             numberOfColCountExact: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountExact).filter(assert_1.isNotUndefined)),
             numberOfColCountValues: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountValues).filter(assert_1.isNotUndefined)),
-            numberOfColCountTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountTop).filter(assert_1.isNotUndefined)),
-            numberOfColCountInfinite: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountInfinite).filter(assert_1.isNotUndefined)),
             numberOfColCountBottom: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountBottom).filter(assert_1.isNotUndefined)),
-            approxRangeColCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeColCount).filter(assert_1.isNotUndefined)),
+            numberOfColCountInfinite: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountInfinite).filter(assert_1.isNotUndefined)),
+            numberOfColCountTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountTop).filter(assert_1.isNotUndefined)),
             inferredRowCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.inferredRowCount).filter(assert_1.isNotUndefined)),
+            approxRangeRowCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeRowCount).filter(assert_1.isNotUndefined)),
             numberOfRowCountExact: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountExact).filter(assert_1.isNotUndefined)),
             numberOfRowCountValues: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountValues).filter(assert_1.isNotUndefined)),
-            numberOfRowCountTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountTop).filter(assert_1.isNotUndefined)),
-            numberOfRowCountInfinite: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountInfinite).filter(assert_1.isNotUndefined)),
             numberOfRowCountBottom: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountBottom).filter(assert_1.isNotUndefined)),
-            approxRangeRowCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeRowCount).filter(assert_1.isNotUndefined)),
+            numberOfRowCountInfinite: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountInfinite).filter(assert_1.isNotUndefined)),
+            numberOfRowCountTop: (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountTop).filter(assert_1.isNotUndefined)),
             perOperationNumber: new Map(semantics_1.DataFrameOperationNames.map(n => [n, (0, summarizer_1.summarizeMeasurement)(stats.map(s => s.dataFrameShape?.perOperationNumber.get(n) ?? 0))]))
         } : undefined
     };
@@ -198,8 +201,8 @@ function summarizeAllUltimateStats(stats) {
             numberOfNonDataFrameFiles: (0, arrays_1.arraySum)(stats.map(s => s.dataFrameShape?.numberOfNonDataFrameFiles).filter(assert_1.isNotUndefined)),
             numberOfResultConstraints: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultConstraints).filter(assert_1.isNotUndefined)),
             numberOfResultingValues: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingValues).filter(assert_1.isNotUndefined)),
-            numberOfResultingTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingTop).filter(assert_1.isNotUndefined)),
             numberOfResultingBottom: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingBottom).filter(assert_1.isNotUndefined)),
+            numberOfResultingTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfResultingTop).filter(assert_1.isNotUndefined)),
             numberOfEmptyNodes: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfEmptyNodes).filter(assert_1.isNotUndefined)),
             numberOfOperationNodes: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfOperationNodes).filter(assert_1.isNotUndefined)),
             numberOfValueNodes: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfValueNodes).filter(assert_1.isNotUndefined)),
@@ -207,26 +210,29 @@ function summarizeAllUltimateStats(stats) {
             numberOfEntriesPerNode: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfEntriesPerNode).filter(assert_1.isNotUndefined)),
             numberOfOperations: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfOperations).filter(assert_1.isNotUndefined)),
             numberOfTotalValues: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalValues).filter(assert_1.isNotUndefined)),
-            numberOfTotalTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalTop).filter(assert_1.isNotUndefined)),
             numberOfTotalBottom: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalBottom).filter(assert_1.isNotUndefined)),
+            numberOfTotalTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfTotalTop).filter(assert_1.isNotUndefined)),
             inferredColNames: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.inferredColNames).filter(assert_1.isNotUndefined)),
+            approxRangeColNames: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeColNames).filter(assert_1.isNotUndefined)),
+            numberOfColNamesExact: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesExact).filter(assert_1.isNotUndefined)),
             numberOfColNamesValues: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesValues).filter(assert_1.isNotUndefined)),
-            numberOfColNamesTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesTop).filter(assert_1.isNotUndefined)),
             numberOfColNamesBottom: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesBottom).filter(assert_1.isNotUndefined)),
+            numberOfColNamesInfinite: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesInfinite).filter(assert_1.isNotUndefined)),
+            numberOfColNamesTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColNamesTop).filter(assert_1.isNotUndefined)),
             inferredColCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.inferredColCount).filter(assert_1.isNotUndefined)),
+            approxRangeColCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeColCount).filter(assert_1.isNotUndefined)),
             numberOfColCountExact: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountExact).filter(assert_1.isNotUndefined)),
             numberOfColCountValues: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountValues).filter(assert_1.isNotUndefined)),
-            numberOfColCountTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountTop).filter(assert_1.isNotUndefined)),
-            numberOfColCountInfinite: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountInfinite).filter(assert_1.isNotUndefined)),
             numberOfColCountBottom: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountBottom).filter(assert_1.isNotUndefined)),
-            approxRangeColCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeColCount).filter(assert_1.isNotUndefined)),
+            numberOfColCountInfinite: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountInfinite).filter(assert_1.isNotUndefined)),
+            numberOfColCountTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfColCountTop).filter(assert_1.isNotUndefined)),
             inferredRowCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.inferredRowCount).filter(assert_1.isNotUndefined)),
+            approxRangeRowCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeRowCount).filter(assert_1.isNotUndefined)),
             numberOfRowCountExact: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountExact).filter(assert_1.isNotUndefined)),
             numberOfRowCountValues: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountValues).filter(assert_1.isNotUndefined)),
-            numberOfRowCountTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountTop).filter(assert_1.isNotUndefined)),
-            numberOfRowCountInfinite: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountInfinite).filter(assert_1.isNotUndefined)),
             numberOfRowCountBottom: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountBottom).filter(assert_1.isNotUndefined)),
-            approxRangeRowCount: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.approxRangeRowCount).filter(assert_1.isNotUndefined)),
+            numberOfRowCountInfinite: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountInfinite).filter(assert_1.isNotUndefined)),
+            numberOfRowCountTop: (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.numberOfRowCountTop).filter(assert_1.isNotUndefined)),
             perOperationNumber: new Map(semantics_1.DataFrameOperationNames.map(n => [n, (0, process_1.summarizeSummarizedMeasurement)(stats.map(s => s.dataFrameShape?.perOperationNumber.get(n)).filter(assert_1.isNotUndefined))]))
         } : undefined
     };

package/control-flow/cfg-dead-code.js

@@ -58,7 +58,8 @@ class CfgConditionalDeadCodeRemoval extends semantic_cfg_guided_visitor_1.Semant
             graph: this.config.dfg,
             full: true,
             idMap: this.config.normalizedAst.idMap,
-            resolve: this.config.ctx.config.solver.variables
+            resolve: this.config.ctx.config.solver.variables,
+            ctx: this.config.ctx,
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
             this.unableToCalculateValue(id);
@@ -83,7 +84,7 @@ class CfgConditionalDeadCodeRemoval extends semantic_cfg_guided_visitor_1.Semant
             graph: this.config.dfg,
             full: true,
             idMap: this.config.normalizedAst.idMap,
-            resolve: this.config.ctx.config.solver.variables
+            ctx: this.config.ctx,
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
             return undefined;

package/control-flow/useless-loop.js

@@ -39,7 +39,8 @@ function onlyLoopsOnce(loop, dataflow, controlflow, ast, ctx) {
         const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(vectorOfLoop.nodeId, {
             graph: dataflow,
             idMap: dataflow.idMap,
-            resolve: ctx.config.solver.variables
+            resolve: ctx.config.solver.variables,
+            ctx: ctx
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type !== 'vector' || !(0, r_value_1.isValue)(values.elements[0].elements)) {
             return undefined;
@@ -75,7 +76,8 @@ class CfgSingleIterationLoopDetector extends semantic_cfg_guided_visitor_1.Seman
             graph: this.config.dfg,
             full: true,
             idMap: this.config.normalizedAst.idMap,
-            resolve: this.config.ctx.config.solver.variables
+            resolve: this.config.ctx.config.solver.variables,
+            ctx: this.config.ctx
         }));
         if (values === undefined || values.elements.length !== 1 || values.elements[0].type != 'logical' || !(0, r_value_1.isValue)(values.elements[0].value)) {
             return undefined;

package/core/steps/all/static-slicing/00-slice.d.ts

@@ -3,6 +3,7 @@ import { PipelineStepStage } from '../../pipeline-step';
 import type { DataflowInformation } from '../../../../dataflow/info';
 import type { SlicingCriteria } from '../../../../slicing/criterion/parse';
 import type { NormalizedAst } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../../../project/context/flowr-analyzer-context';
 export interface SliceRequiredInput {
     /** The slicing criterion is only of interest if you actually want to slice the R code */
     readonly criterion: SlicingCriteria;
@@ -10,6 +11,8 @@ export interface SliceRequiredInput {
     readonly threshold?: number;
     /** The direction to slice in. Defaults to backward slicing if unset. */
     readonly direction?: SliceDirection;
+    /** The context of the analysis */
+    readonly context?: ReadOnlyFlowrAnalyzerContext;
 }
 export declare enum SliceDirection {
     Backward = "backward",

package/core/steps/all/static-slicing/00-slice.js

@@ -10,7 +10,8 @@ var SliceDirection;
 })(SliceDirection || (exports.SliceDirection = SliceDirection = {}));
 function processor(results, input) {
     const direction = input.direction ?? SliceDirection.Backward;
-    return (0, static_slicer_1.staticSlice)(results.dataflow, results.normalize, input.criterion, direction, input.threshold);
+    const threshold = input.threshold ?? input.context?.config.solver.slicer?.threshold;
+    return (0, static_slicer_1.staticSlice)(input.context, results.dataflow, results.normalize, input.criterion, direction, threshold);
 }
 exports.STATIC_SLICE = {
     name: 'slice',

package/core/steps/pipeline/default-pipelines.d.ts

@@ -22,6 +22,20 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "normalize";
     readonly humanReadableName: "normalize";
@@ -39,20 +53,6 @@ export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
@@ -106,6 +106,20 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "normalize";
     readonly humanReadableName: "normalize";
@@ -123,20 +137,6 @@ export declare const DEFAULT_SLICE_AND_RECONSTRUCT_PIPELINE: import("./pipeline"
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {
@@ -190,6 +190,20 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     };
     readonly dependencies: readonly [];
     readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly name: "normalize";
     readonly humanReadableName: "normalize";
@@ -207,20 +221,6 @@ export declare const DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE: import("./pipel
     };
     readonly dependencies: readonly ["parse"];
     readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
-} | {
-    readonly name: "slice";
-    readonly humanReadableName: "static slice";
-    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
-    readonly processor: (results: {
-        dataflow?: import("../../../dataflow/info").DataflowInformation;
-        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
-    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
-    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
-    readonly printer: {
-        readonly 0: typeof import("../../print/print").internalPrinter;
-    };
-    readonly dependencies: readonly ["dataflow"];
-    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
 } | {
     readonly humanReadableName: "dataflow";
     readonly processor: (results: {

package/dataflow/cluster.js

@@ -10,13 +10,13 @@ const assert_1 = require("../util/assert");
 function findAllClusters(graph) {
     const clusters = [];
     // we reverse the vertices since dependencies usually point "backwards" from later nodes
-    const notReached = new Set([...graph.vertices(true)].map(([id]) => id).reverse());
+    const notReached = new Set(graph.vertices(true).map(([id]) => id).toArray().reverse());
     while (notReached.size > 0) {
         const [startNode] = notReached;
         notReached.delete(startNode);
         clusters.push({
             startNode: startNode,
-            members: [...makeCluster(graph, startNode, notReached)],
+            members: Array.from(makeCluster(graph, startNode, notReached)),
             hasUnknownSideEffects: graph.unknownSideEffects.has(startNode)
         });
     }

package/dataflow/environments/append.d.ts

@@ -1,4 +1,9 @@
 import { type REnvironmentInformation } from './environment';
+import type { IdentifierDefinition } from './identifier';
+/**
+ * Merges two arrays of identifier definitions, ensuring uniqueness based on `nodeId` and `definedAt`.
+ */
+export declare function uniqueMergeValuesInDefinitions(old: IdentifierDefinition[], value: readonly IdentifierDefinition[]): IdentifierDefinition[];
 /**
  * Adds all writes of `next` to `base` (i.e., the operations of `next` *might* happen).
  */

package/dataflow/environments/append.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueMergeValuesInDefinitions = uniqueMergeValuesInDefinitions;
 exports.appendEnvironment = appendEnvironment;
 const assert_1 = require("../../util/assert");
-const environment_1 = require("./environment");
-function uniqueMergeValues(old, value) {
+/**
+ * Merges two arrays of identifier definitions, ensuring uniqueness based on `nodeId` and `definedAt`.
+ */
+function uniqueMergeValuesInDefinitions(old, value) {
     const result = old;
     for (const v of value) {
         const find = result.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
@@ -13,23 +16,6 @@ function uniqueMergeValues(old, value) {
     }
     return result;
 }
-function appendIEnvironmentWith(base, next) {
-    (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not append environments with undefined');
-    const map = new Map(base.memory);
-    for (const [key, value] of next.memory) {
-        const old = map.get(key);
-        if (old) {
-            map.set(key, uniqueMergeValues(old, value));
-        }
-        else {
-            map.set(key, value);
-        }
-    }
-    const parent = base.parent.builtInEnv ? base.parent : appendIEnvironmentWith(base.parent, next.parent);
-    const out = new environment_1.Environment(parent);
-    out.memory = map;
-    return out;
-}
 function appendEnvironment(base, next) {
     if (base === undefined) {
         return next;
@@ -39,7 +25,7 @@ function appendEnvironment(base, next) {
     }
     (0, assert_1.guard)(base.level === next.level, 'environments must have the same level to be handled, it is up to the caller to ensure that');
     return {
-        current: appendIEnvironmentWith(base.current, next.current),
+        current: base.current.append(next.current),
         level: base.level,
     };
 }

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

@@ -33,6 +33,7 @@ import { resolveAsMinus, resolveAsPlus, resolveAsSeq, resolveAsVector } from '..
 import type { DataflowGraph } from '../graph/graph';
 import type { VariableResolve } from '../../config';
 import type { BuiltInConstantDefinition, BuiltInDefinition, BuiltInFunctionDefinition, BuiltInReplacementDefinition } from './built-in-config';
+import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-analyzer-context';
 export type BuiltIn = `built-in:${string}`;
 /**
  * Generate a built-in id for the given name
@@ -69,7 +70,7 @@ export interface DefaultBuiltInProcessorConfiguration extends ForceArguments {
      */
     readonly useAsProcessor?: UseAsProcessors;
 }
-export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
+export type BuiltInEvalHandler = (resolve: VariableResolve, a: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap) => Value;
 declare function defaultBuiltInProcessor<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, { returnsNthArgument, useAsProcessor, forceArgs, readAllArguments, cfg, hasUnknownSideEffects, treatAsFnCall }: DefaultBuiltInProcessorConfiguration): DataflowInformation;
 export declare const BuiltInProcessorMapper: {
     readonly 'builtin:default': typeof defaultBuiltInProcessor;

package/dataflow/environments/clone.d.ts

@@ -4,4 +4,4 @@ import { type REnvironmentInformation } from './environment';
  * @param environment        - The environment information to clone.
  * @param recurseParents     - Whether to clone the parent environments as well.
  */
-export declare function cloneEnvironmentInformation(environment: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;
+export declare function cloneEnvironmentInformation({ current, level }: REnvironmentInformation, recurseParents?: boolean): REnvironmentInformation;

package/dataflow/environments/clone.js

@@ -1,39 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cloneEnvironmentInformation = cloneEnvironmentInformation;
-const environment_1 = require("./environment");
-function cloneEnvironment(environment, recurseParents) {
-    if (environment === undefined) {
-        return undefined;
-    }
-    else if (environment.builtInEnv) {
-        return environment; // do not clone the built-in environment
-    }
-    /* make sure the clone has the same id */
-    const clone = new environment_1.Environment(recurseParents ? cloneEnvironment(environment.parent, recurseParents) : environment.parent, environment.builtInEnv);
-    if (environment.memory.size < 10) {
-        clone.memory = new Map(JSON.parse(JSON.stringify(environment.memory.entries().toArray())));
-    }
-    else {
-        clone.memory = new Map(environment.memory.entries()
-            .map(([k, v]) => [k,
-            v.map(s => ({
-                ...s,
-                controlDependencies: s.controlDependencies?.slice()
-            }))
-        ]));
-    }
-    return clone;
-}
 /**
  * Produce a clone of the given environment information.
  * @param environment        - The environment information to clone.
  * @param recurseParents     - Whether to clone the parent environments as well.
  */
-function cloneEnvironmentInformation(environment, recurseParents = true) {
+function cloneEnvironmentInformation({ current, level }, recurseParents = true) {
     return {
-        current: cloneEnvironment(environment.current, recurseParents),
-        level: environment.level
+        current: current.clone(recurseParents),
+        level
     };
 }
 //# sourceMappingURL=clone.js.map

package/dataflow/environments/define.d.ts

@@ -1,12 +1,16 @@
 import type { REnvironmentInformation } from './environment';
-import type { IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
+import type { Identifier, IdentifierDefinition, InGraphIdentifierDefinition } from './identifier';
 import type { FlowrConfigOptions } from '../../config';
 /**
  * assumes: existing is not undefined, the overwrite has indices
  */
-export declare function mergeDefinitions(existing: readonly IdentifierDefinition[], definition: InGraphIdentifierDefinition): InGraphIdentifierDefinition[];
+export declare function mergeDefinitionsForPointer(existing: readonly IdentifierDefinition[], definition: InGraphIdentifierDefinition): InGraphIdentifierDefinition[];
 /**
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.
+ * @see {@link Environment#define}      - for details on how (local) definitions are handled.
+ * @see {@link Environment#defineSuper} - for details on how (super) definitions are handled.
  */
-export declare function define(definition: IdentifierDefinition, superAssign: boolean | undefined, environment: REnvironmentInformation, config: FlowrConfigOptions): REnvironmentInformation;
+export declare function define(definition: IdentifierDefinition & {
+    name: Identifier;
+}, superAssign: boolean | undefined, { level, current }: REnvironmentInformation, config: FlowrConfigOptions): REnvironmentInformation;

package/dataflow/environments/define.js

@@ -1,39 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeDefinitions = mergeDefinitions;
+exports.mergeDefinitionsForPointer = mergeDefinitionsForPointer;
 exports.define = define;
 const assert_1 = require("../../util/assert");
-const clone_1 = require("./clone");
 const vertex_1 = require("../graph/vertex");
-function defInEnv(newEnvironments, name, definition, config) {
-    const existing = newEnvironments.memory.get(name);
-    // When there are defined indices, merge the definitions
-    const inGraphDefinition = definition;
-    if (config.solver.pointerTracking &&
-        existing !== undefined &&
-        inGraphDefinition.controlDependencies === undefined) {
-        if (inGraphDefinition.indicesCollection !== undefined) {
-            newEnvironments.memory.set(name, mergeDefinitions(existing, inGraphDefinition));
-            return;
-        }
-        else if (existing?.flatMap(i => i.indicesCollection ?? []).length > 0) {
-            // When indices couldn't be resolved, but indices where defined before, just add the definition
-            existing.push(definition);
-            return;
-        }
-    }
-    // check if it is maybe or not
-    if (existing === undefined || definition.controlDependencies === undefined) {
-        newEnvironments.memory.set(name, [definition]);
-    }
-    else {
-        existing.push(definition);
-    }
-}
 /**
  * assumes: existing is not undefined, the overwrite has indices
  */
-function mergeDefinitions(existing, definition) {
+function mergeDefinitionsForPointer(existing, definition) {
     // When new definition is not a single index, e.g., a list redefinition, then reset existing definition
     if (definition.indicesCollection?.some(indices => indices.isContainer)) {
         return [definition];
@@ -119,34 +93,13 @@ function overwriteContainerIndices(existingIndices, overwriteIndex) {
 /**
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.
+ * @see {@link Environment#define}      - for details on how (local) definitions are handled.
+ * @see {@link Environment#defineSuper} - for details on how (super) definitions are handled.
  */
-function define(definition, superAssign, environment, config) {
-    const name = definition.name;
-    (0, assert_1.guard)(name !== undefined, () => `Name must be defined, but isn't for ${JSON.stringify(definition)}`);
-    let newEnvironment;
-    if (superAssign) {
-        newEnvironment = (0, clone_1.cloneEnvironmentInformation)(environment, true);
-        let current = newEnvironment.current;
-        let last = undefined;
-        let found = false;
-        do {
-            if (current.memory.has(name)) {
-                current.memory.set(name, [definition]);
-                found = true;
-                break;
-            }
-            last = current;
-            current = current.parent;
-        } while (!current.builtInEnv);
-        if (!found) {
-            (0, assert_1.guard)(last !== undefined, () => `Could not find global scope for ${name}`);
-            last.memory.set(name, [definition]);
-        }
-    }
-    else {
-        newEnvironment = (0, clone_1.cloneEnvironmentInformation)(environment, false);
-        defInEnv(newEnvironment.current, name, definition, config);
-    }
-    return newEnvironment;
+function define(definition, superAssign, { level, current }, config) {
+    return {
+        level,
+        current: superAssign ? current.defineSuper(definition) : current.define(definition, config),
+    };
 }
 //# sourceMappingURL=define.js.map

package/dataflow/environments/diff.js

@@ -69,7 +69,7 @@ function diffEnvironment(a, b, info, depth) {
     }
     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()]), {
+        (0, diff_1.setDifference)(new Set(a.memory.keys()), new Set(b.memory.keys()), {
             ...info,
             position: `${info.position}[at level: ${depth}] Key comparison. `
         });