@eagleoutice/flowr 2.6.2 → 2.7.0

package/benchmark/slicer.js

@@ -28,7 +28,10 @@ const config_1 = require("../config");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
 const absint_info_1 = require("../abstract-interpretation/data-frame/absint-info");
 const shape_inference_1 = require("../abstract-interpretation/data-frame/shape-inference");
+const lattice_1 = require("../abstract-interpretation/domains/lattice");
+const set_range_domain_1 = require("../abstract-interpretation/domains/set-range-domain");
 const fs_1 = __importDefault(require("fs"));
+const flowr_analyzer_context_1 = require("../project/context/flowr-analyzer-context");
 /**
  * The logger to be used for benchmarking as a global object.
  */
@@ -40,6 +43,7 @@ class BenchmarkSlicer {
     deltas = new Map();
     parserName;
     config;
+    context;
     stats;
     loadedXml;
     dataflow;
@@ -71,13 +75,14 @@ class BenchmarkSlicer {
                 return new tree_sitter_executor_1.TreeSitterExecutor();
             }
         });
+        this.context = (0, flowr_analyzer_context_1.contextFromInput)({ ...request }, config);
         this.executor = (0, default_pipelines_1.createSlicePipeline)(this.parser, {
-            request: { ...request },
+            context: this.context,
             criterion: [],
             autoSelectIf,
             threshold,
-        }, config);
-        this.loadedXml = (await this.measureCommonStep('parse', 'retrieve AST from R code')).parsed;
+        });
+        this.loadedXml = (await this.measureCommonStep('parse', 'retrieve AST from R code')).files.map(p => p.parsed);
         this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
         this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information');
         this.executor.switchToRequestStage();
@@ -100,9 +105,9 @@ class BenchmarkSlicer {
                 }
                 return ret;
             };
-            const root = this.loadedXml.rootNode;
-            numberOfRTokens = countChildren(root);
-            numberOfRTokensNoComments = countChildren(root, true);
+            const root = this.loadedXml.map(t => t.rootNode);
+            numberOfRTokens = root.map(r => countChildren(r)).reduce((a, b) => a + b, 0);
+            numberOfRTokensNoComments = root.map(r => countChildren(r, true)).reduce((a, b) => a + b, 0);
         }
         (0, assert_1.guard)(this.normalizedAst !== undefined, 'normalizedAst should be defined after initialization');
         (0, assert_1.guard)(this.dataflow !== undefined, 'dataflow should be defined after initialization');
@@ -114,10 +119,10 @@ class BenchmarkSlicer {
         for (const [n, info] of vertices) {
             const outgoingEdges = this.dataflow.graph.outgoingEdges(n);
             numberOfEdges += outgoingEdges?.size ?? 0;
-            if (info.tag === 'function-call') {
+            if (info.tag === vertex_1.VertexType.FunctionCall) {
                 numberOfCalls++;
             }
-            else if (info.tag === 'function-definition') {
+            else if (info.tag === vertex_1.VertexType.FunctionDefinition) {
                 numberOfDefinitions++;
             }
         }
@@ -125,7 +130,7 @@ class BenchmarkSlicer {
         let nodesNoComments = 0;
         let commentChars = 0;
         let commentCharsNoWhitespace = 0;
-        (0, visitor_1.visitAst)(this.normalizedAst.ast, t => {
+        (0, visitor_1.visitAst)(this.normalizedAst.ast.files.map(f => f.root), t => {
             nodes++;
             const comments = t.info.additionalTokens?.filter(t => t.type === type_1.RType.Comment);
             if (comments && comments.length > 0) {
@@ -160,7 +165,7 @@ class BenchmarkSlicer {
                 numberOfNormalizedTokensNoComments: nodesNoComments
             },
             dataflow: {
-                numberOfNodes: [...this.dataflow.graph.vertices(true)].length,
+                numberOfNodes: this.dataflow.graph.vertices(true).toArray().length,
                 numberOfEdges: numberOfEdges,
                 numberOfCalls: numberOfCalls,
                 numberOfFunctionDefinitions: numberOfDefinitions,
@@ -254,7 +259,7 @@ class BenchmarkSlicer {
             }).join('')}`);
         }
         // if it is not in the dataflow graph it was kept to be safe and should not count to the included nodes
-        stats.numberOfDataflowNodesSliced = [...slicedOutput.result].filter(id => results.dataflow.graph.hasVertex(id, false)).length;
+        stats.numberOfDataflowNodesSliced = Array.from(slicedOutput.result).filter(id => results.dataflow.graph.hasVertex(id, false)).length;
         stats.timesHitThreshold = slicedOutput.timesHitThreshold;
         stats.measurements = measurements.get();
         return {
@@ -274,8 +279,7 @@ class BenchmarkSlicer {
         (0, assert_1.guard)(this.config !== undefined, 'config should be defined for control flow extraction');
         const ast = this.normalizedAst;
         const dfg = this.dataflow.graph;
-        const config = this.config;
-        this.controlFlow = this.measureSimpleStep('extract control flow graph', () => (0, extract_cfg_1.extractCfg)(ast, config, dfg));
+        this.controlFlow = this.measureSimpleStep('extract control flow graph', () => (0, extract_cfg_1.extractCfg)(ast, this.context, dfg));
     }
     /**
      * Infer the shape of data frames using abstract interpretation with {@link inferDataFrameShapes}
@@ -291,21 +295,20 @@ class BenchmarkSlicer {
         const ast = this.normalizedAst;
         const dfg = this.dataflow.graph;
         const cfinfo = this.controlFlow;
-        const config = this.config;
         const stats = {
             numberOfDataFrameFiles: 0,
             numberOfNonDataFrameFiles: 0,
             numberOfResultConstraints: 0,
             numberOfResultingValues: 0,
-            numberOfResultingTop: 0,
             numberOfResultingBottom: 0,
+            numberOfResultingTop: 0,
             numberOfEmptyNodes: 0,
             numberOfOperationNodes: 0,
             numberOfValueNodes: 0,
             sizeOfInfo: 0,
             perNodeStats: new Map()
         };
-        const result = this.measureSimpleStep('infer data frame shapes', () => (0, shape_inference_1.inferDataFrameShapes)(cfinfo, dfg, ast, config));
+        const result = this.measureSimpleStep('infer data frame shapes', () => (0, shape_inference_1.inferDataFrameShapes)(cfinfo, dfg, ast, this.context));
         stats.numberOfResultConstraints = result.value.size;
         for (const value of result.value.values()) {
             if (value.isTop()) {
@@ -318,7 +321,7 @@ class BenchmarkSlicer {
                 stats.numberOfResultingValues++;
             }
         }
-        (0, visitor_1.visitAst)(this.normalizedAst.ast, (node) => {
+        (0, visitor_1.visitAst)(this.normalizedAst.ast.files.map(f => f.root), (node) => {
             if (node.info.dataFrame === undefined) {
                 return;
             }
@@ -337,11 +340,12 @@ class BenchmarkSlicer {
                 nodeStats.mappedOperations = expression.operations.map(op => op.operation);
                 stats.numberOfOperationNodes++;
                 if (value !== undefined) {
-                    nodeStats.inferredColNames = value.colnames.isValue() ? value.colnames.value.size : value.colnames.isTop() ? 'top' : 'bottom';
-                    nodeStats.inferredColCount = this.getInferredSize(value.cols);
-                    nodeStats.inferredRowCount = this.getInferredSize(value.rows);
-                    nodeStats.approxRangeColCount = value.cols.isValue() ? value.cols.value[1] - value.cols.value[0] : 0;
-                    nodeStats.approxRangeRowCount = value.rows.isValue() ? value.rows.value[1] - value.rows.value[0] : 0;
+                    nodeStats.inferredColNames = this.getInferredNumber(value.colnames);
+                    nodeStats.inferredColCount = this.getInferredNumber(value.cols);
+                    nodeStats.inferredRowCount = this.getInferredNumber(value.rows);
+                    nodeStats.approxRangeColNames = this.getInferredRange(value.colnames);
+                    nodeStats.approxRangeColCount = this.getInferredRange(value.cols);
+                    nodeStats.approxRangeRowCount = this.getInferredRange(value.rows);
                 }
             }
             if (value !== undefined) {
@@ -358,15 +362,34 @@ class BenchmarkSlicer {
         this.stats.dataFrameShape = stats;
         return stats;
     }
-    getInferredSize(value) {
+    getInferredRange(value) {
+        if (value.isValue()) {
+            if (value instanceof set_range_domain_1.SetRangeDomain) {
+                return value.value.range === lattice_1.Top ? Infinity : value.value.range.size;
+            }
+            else {
+                return value.value[1] - value.value[0];
+            }
+        }
+        return 0;
+    }
+    getInferredNumber(value) {
         if (value.isTop()) {
             return 'top';
         }
-        else if (value.isValue() && !isFinite(value.value[1])) {
-            return 'infinite';
-        }
         else if (value.isValue()) {
-            return Math.floor((value.value[0] + value.value[1]) / 2);
+            if (value instanceof set_range_domain_1.SetRangeDomain) {
+                if (value.value.range === lattice_1.Top) {
+                    return 'infinite';
+                }
+                return Math.floor(value.value.min.size + (value.value.range.size / 2));
+            }
+            else {
+                if (!isFinite(value.value[1])) {
+                    return 'infinite';
+                }
+                return Math.floor((value.value[0] + value.value[1]) / 2);
+            }
         }
         return 'bottom';
     }

package/benchmark/stats/print.js

@@ -176,15 +176,16 @@ Dataframe shape inference:
   Number of total top:            ${pad(stats.dataFrameShape.numberOfTotalTop)}
   Inferred column names per node: ${pad(stats.dataFrameShape.inferredColNames.mean)}
   Number of column names values:  ${pad(stats.dataFrameShape.numberOfColNamesValues)}
-  Number of column names Top:     ${pad(stats.dataFrameShape.numberOfColNamesTop)}
+  Number of column names infinite:${pad(stats.dataFrameShape.numberOfColNamesInfinite)}
+  Number of column names top:     ${pad(stats.dataFrameShape.numberOfColNamesTop)}
   Inferred column count per node: ${pad(stats.dataFrameShape.inferredColCount.mean)}
   Number of column count values:  ${pad(stats.dataFrameShape.numberOfColCountValues)}
-  Number of column count Top:     ${pad(stats.dataFrameShape.numberOfColCountTop)}
   Number of column count infinite:${pad(stats.dataFrameShape.numberOfColCountInfinite)}
+  Number of column count top:     ${pad(stats.dataFrameShape.numberOfColCountTop)}
   Inferred row count per node:    ${pad(stats.dataFrameShape.inferredRowCount.mean)}
   Number of row count values:     ${pad(stats.dataFrameShape.numberOfRowCountValues)}
-  Number of row count Top:        ${pad(stats.dataFrameShape.numberOfRowCountTop)}
   Number of row count infinite:   ${pad(stats.dataFrameShape.numberOfRowCountInfinite)}
+  Number of row count top:        ${pad(stats.dataFrameShape.numberOfRowCountTop)}
   Size of data frame shape info:  ${convertNumberToNiceBytes(stats.dataFrameShape.sizeOfInfo)}`;
     }
     return result;
@@ -276,18 +277,20 @@ Dataframe shape inference:
   Number of total values:         ${formatSummarizedMeasure(stats.dataFrameShape.numberOfTotalValues)}
   Number of total top:            ${formatSummarizedMeasure(stats.dataFrameShape.numberOfTotalTop)}
   Inferred column names per node: ${formatSummarizedMeasure(stats.dataFrameShape.inferredColNames)}
+  Number of column names exact:   ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColNamesExact)}
   Number of column names values:  ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColNamesValues)}
+  Number of column names infinite:${formatSummarizedMeasure(stats.dataFrameShape.numberOfColNamesInfinite)}
   Number of column names top:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColNamesTop)}
   Inferred column count per node: ${formatSummarizedMeasure(stats.dataFrameShape.inferredColCount)}
   Number of column count exact:   ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountExact)}
   Number of column count values:  ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountValues)}
-  Number of column count top:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountTop)}
   Number of column count infinite:${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountInfinite)}
+  Number of column count top:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfColCountTop)}
   Inferred row count per node:    ${formatSummarizedMeasure(stats.dataFrameShape.inferredRowCount)}
   Number of row count exact:      ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountExact)}
   Number of row count values:     ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountValues)}
-  Number of row count top:        ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountTop)}
   Number of row count infinite:   ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountInfinite)}
+  Number of row count top:        ${formatSummarizedMeasure(stats.dataFrameShape.numberOfRowCountTop)}
   Size of data frame shape info:  ${formatSummarizedMeasure(stats.dataFrameShape.sizeOfInfo, convertNumberToNiceBytes)}`;
     }
     return result;

package/benchmark/stats/stats.d.ts

@@ -49,8 +49,8 @@ export interface SlicerStatsDfShape<T = number> {
     numberOfNonDataFrameFiles: T extends number ? 0 | 1 : number;
     numberOfResultConstraints: T;
     numberOfResultingValues: T;
-    numberOfResultingTop: T;
     numberOfResultingBottom: T;
+    numberOfResultingTop: T;
     numberOfEmptyNodes: T;
     numberOfOperationNodes: T;
     numberOfValueNodes: T;
@@ -60,10 +60,11 @@ export interface SlicerStatsDfShape<T = number> {
 export interface PerNodeStatsDfShape<T = number> {
     numberOfEntries: T;
     mappedOperations?: DataFrameOperationName[];
-    inferredColNames?: T | 'bottom' | 'top';
+    inferredColNames?: T | 'bottom' | 'infinite' | 'top';
     inferredColCount?: T | 'bottom' | 'infinite' | 'top';
     inferredRowCount?: T | 'bottom' | 'infinite' | 'top';
     /** difference between upper and lower bound of interval domain (to estimate approximation) */
+    approxRangeColNames?: T;
     approxRangeColCount?: T;
     approxRangeRowCount?: T;
 }

package/benchmark/summarizer/data.d.ts

@@ -84,25 +84,28 @@ export interface SummarizedDfShapeStats<T = number> extends Omit<SlicerStatsDfSh
     numberOfEntriesPerNode: SummarizedMeasurement;
     numberOfOperations: T;
     numberOfTotalValues: T;
-    numberOfTotalTop: T;
     numberOfTotalBottom: T;
+    numberOfTotalTop: T;
     inferredColNames: SummarizedMeasurement;
+    approxRangeColNames: SummarizedMeasurement;
+    numberOfColNamesExact: T;
     numberOfColNamesValues: T;
-    numberOfColNamesTop: T;
     numberOfColNamesBottom: T;
+    numberOfColNamesInfinite: T;
+    numberOfColNamesTop: T;
     inferredColCount: SummarizedMeasurement;
+    approxRangeColCount: SummarizedMeasurement;
     numberOfColCountExact: T;
     numberOfColCountValues: T;
-    numberOfColCountTop: T;
-    numberOfColCountInfinite: T;
     numberOfColCountBottom: T;
-    approxRangeColCount: SummarizedMeasurement;
+    numberOfColCountInfinite: T;
+    numberOfColCountTop: T;
     inferredRowCount: SummarizedMeasurement;
+    approxRangeRowCount: SummarizedMeasurement;
     numberOfRowCountExact: T;
     numberOfRowCountValues: T;
-    numberOfRowCountTop: T;
-    numberOfRowCountInfinite: T;
     numberOfRowCountBottom: T;
-    approxRangeRowCount: SummarizedMeasurement;
+    numberOfRowCountInfinite: T;
+    numberOfRowCountTop: T;
     perOperationNumber: Map<DataFrameOperationName, T>;
 }

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

@@ -159,7 +159,7 @@ async function summarizeSlicerStats(stats, report = () => {
             let numberOfNormalizedTokensNoComments = 0;
             let commentChars = 0;
             let commentCharsNoWhitespace = 0;
-            (0, visitor_1.visitAst)(reParsed.ast, t => {
+            (0, visitor_1.visitAst)(reParsed.ast.files.map(f => f.root), t => {
                 numberOfNormalizedTokens++;
                 const comments = t.info.additionalTokens?.filter(t => t.type === type_1.RType.Comment);
                 if (comments && comments.length > 0) {
@@ -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/graph.d.ts

@@ -1,5 +1,7 @@
 import type { UltimateSlicerStats } from '../data';
 /**
- *
+ * Write the graph output for the ultimate slicer stats to a file
+ * @param ultimate - The ultimate slicer stats
+ * @param outputGraphPath - The path to write the graph output to
  */
 export declare function writeGraphOutput(ultimate: UltimateSlicerStats, outputGraphPath: string): void;

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

@@ -7,7 +7,9 @@ exports.writeGraphOutput = writeGraphOutput;
 const fs_1 = __importDefault(require("fs"));
 const json_1 = require("../../../util/json");
 /**
- *
+ * Write the graph output for the ultimate slicer stats to a file
+ * @param ultimate - The ultimate slicer stats
+ * @param outputGraphPath - The path to write the graph output to
  */
 function writeGraphOutput(ultimate, outputGraphPath) {
     console.log(`Producing benchmark graph data (${outputGraphPath})...`);

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/cli/export-quads-app.js

@@ -21,7 +21,7 @@ const options = (0, script_1.processCommandLineArgs)('export-quads', [], {
 const shell = new shell_1.RShell((0, config_1.getEngineConfig)((0, config_1.getConfig)(), 'r-shell'));
 async function writeQuadForSingleFile(request, output) {
     const normalized = await (0, retriever_1.retrieveNormalizedAstFromRCode)(request, shell);
-    const serialized = (0, quads_1.serialize2quads)(normalized.ast, { context: request.content });
+    const serialized = (0, quads_1.serialize2quads)(normalized.ast.files[0].root, { context: request.content });
     log_1.log.info(`Appending quads to ${output}`);
     fs_1.default.appendFileSync(output, serialized);
 }

package/cli/repl/commands/repl-dataflow.js

@@ -57,7 +57,8 @@ exports.dataflowCommand = {
             clipboard.default.writeSync(mermaid);
             output.stdout(formatInfo(output, 'mermaid code', result));
         }
-        catch { /* do nothing this is a service thing */ }
+        catch { /* do nothing this is a service thing */
+        }
     }
 };
 exports.dataflowStarCommand = {

package/cli/repl/commands/repl-parse.js

@@ -4,6 +4,7 @@ exports.parseCommand = void 0;
 const format_1 = require("../../../r-bridge/lang-4.x/ast/parser/json/format");
 const normalize_meta_1 = require("../../../r-bridge/lang-4.x/ast/parser/main/normalize-meta");
 const retriever_1 = require("../../../r-bridge/retriever");
+const flowr_file_1 = require("../../../project/context/flowr-file");
 function toDepthMap(entry) {
     const visit = [{ depth: 0, node: entry }];
     const result = [];
@@ -138,15 +139,26 @@ exports.parseCommand = {
         };
     },
     fn: async ({ output, analyzer }) => {
-        const result = await analyzer.parse();
+        const result = (await analyzer.parse()).files;
         const parserInfo = analyzer.parserInformation();
         if (parserInfo.name === 'r-shell') {
-            const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parsed));
-            output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));
+            for (const { parsed, filePath } of result) {
+                if (filePath && filePath !== flowr_file_1.FlowrFile.INLINE_PATH) {
+                    output.stdout(output.formatter.format(`File: ${filePath}\n`, { style: 4 /* FontStyles.Underline */ }));
+                }
+                const object = toDepthMap((0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(parsed)));
+                output.stdout(depthListToTextTree(object, output.formatter));
+            }
         }
         else {
             // print the tree-sitter ast
-            output.stdout(depthListToTextTree(treeSitterToDepthList(result.parsed.rootNode), output.formatter));
+            for (const { parsed, filePath } of result) {
+                if (filePath && filePath !== flowr_file_1.FlowrFile.INLINE_PATH) {
+                    output.stdout(output.formatter.format(`File: ${filePath}\n`, { style: 4 /* FontStyles.Underline */ }));
+                }
+                const object = treeSitterToDepthList(parsed.rootNode);
+                output.stdout(depthListToTextTree(object, output.formatter));
+            }
         }
     }
 };

package/cli/repl/commands/repl-query.js

@@ -65,7 +65,7 @@ async function processQueryArgs(output, analyzer, remainingArgs) {
     }
     if (input) {
         analyzer.reset();
-        analyzer.addRequest((0, retriever_1.requestFromInput)(input));
+        analyzer.addRequest(input);
     }
     return {
         query: await (0, query_1.executeQueries)({

package/cli/repl/core.js

@@ -150,28 +150,30 @@ async function replProcessStatement(output, statement, analyzer, allowRSessionAc
         const bold = (s) => output.formatter.format(s, { style: 1 /* FontStyles.Bold */ });
         if (processor) {
             try {
-                const remainingLine = statement.slice(command.length + 2).trim();
-                if (processor.isCodeCommand) {
-                    const args = processor.argsParser(remainingLine);
-                    if (args.rCode) {
-                        analyzer.reset();
-                        analyzer.addRequest((0, retriever_1.requestFromInput)(args.rCode));
+                await (0, query_1.genericWrapReplFailIfNoRequest)(async () => {
+                    const remainingLine = statement.slice(command.length + 2).trim();
+                    if (processor.isCodeCommand) {
+                        const args = processor.argsParser(remainingLine);
+                        if (args.rCode) {
+                            analyzer.reset();
+                            analyzer.addRequest(args.rCode);
+                        }
+                        await processor.fn({ output, analyzer, remainingArgs: args.remaining });
                     }
-                    await processor.fn({ output, analyzer, remainingArgs: args.remaining });
-                }
-                else {
-                    await processor.fn({ output, analyzer, remainingLine, allowRSessionAccess });
-                }
+                    else {
+                        await processor.fn({ output, analyzer, remainingLine, allowRSessionAccess });
+                    }
+                }, output, analyzer);
             }
             catch (e) {
-                output.stdout(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);
+                output.stderr(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);
                 if (log_1.log.settings.minLevel < 6 /* LogLevel.Fatal */) {
                     console.error(e);
                 }
             }
         }
         else {
-            output.stdout(`the command '${command}' is unknown, try ${bold(':help')} for more information\n`);
+            output.stderr(`the command '${command}' is unknown, try ${bold(':help')} for more information\n`);
         }
     }
     else {
@@ -206,6 +208,7 @@ async function repl({ analyzer, rl = readline.createInterface(makeDefaultReplRea
         rl.on('history', h => fs_1.default.writeFileSync(historyFile, h.join('\n'), { encoding: 'utf-8' }));
     }
     // the incredible repl :D, we kill it with ':quit'
+    // noinspection InfiniteLoopJS
     while (true) {
         await new Promise((resolve, reject) => {
             rl.question((0, prompt_1.prompt)(), answer => {

package/cli/repl/server/connection.js

@@ -214,10 +214,11 @@ class FlowRServerConnection {
         else {
             throw new Error('Either content or filepath must be defined.');
         }
-        const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(request)
+        const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
             .setConfig(this.config)
             .setParser(this.parser)
             .build();
+        analyzer.addRequest(request);
         if (message.filetoken) {
             this.logger.info(`Storing file token ${message.filetoken}`);
             this.fileMap.set(message.filetoken, {

package/cli/script-core/statistics-helper-core.js

@@ -21,6 +21,7 @@ const time_1 = require("../../util/text/time");
 const tar_1 = require("tar");
 const ansi_1 = require("../../util/text/ansi");
 const config_1 = require("../../config");
+const flowr_analyzer_context_1 = require("../../project/context/flowr-analyzer-context");
 function compressFolder(folder, target) {
     return (0, tar_1.create)({
         gzip: true,
@@ -62,7 +63,7 @@ async function getStatsForSingleFile(options, config) {
     if (stats.outputs.size === 1) {
         if (options['dump-json']) {
             const [, output] = [...stats.outputs.entries()][0];
-            const cfg = (0, extract_cfg_1.extractCfg)(output.normalize, config, output.dataflow.graph);
+            const cfg = (0, extract_cfg_1.extractCfg)(output.normalize, (0, flowr_analyzer_context_1.contextFromInput)('', config), output.dataflow.graph);
             statistics_file_1.statisticsFileProvider.append('output-json', 'parse', await (0, print_1.printStepResult)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, output.parse, 2 /* StepOutputFormat.Json */));
             statistics_file_1.statisticsFileProvider.append('output-json', 'normalize', await (0, print_1.printStepResult)(_10_normalize_1.NORMALIZE, output.normalize, 2 /* StepOutputFormat.Json */));
             statistics_file_1.statisticsFileProvider.append('output-json', 'dataflow', await (0, print_1.printStepResult)(_20_dataflow_1.STATIC_DATAFLOW, output.dataflow, 2 /* StepOutputFormat.Json */));