@eagleoutice/flowr 2.1.7 → 2.1.9

package/r-bridge/lang-4.x/ast/parser/json/format.js

@@ -10,10 +10,10 @@ exports.RootId = 0;
 function prepareParsedData(data) {
     let json;
     try {
-        json = JSON.parse(`[${data}]`);
+        json = JSON.parse(`[${data.trim()}]`);
     }
     catch (e) {
-        throw new Error(`Failed to parse data ${data}: ${e?.message}`);
+        throw new Error(`Failed to parse data [${data}]: ${e?.message}`);
     }
     (0, assert_1.guard)(Array.isArray(json), () => `Expected ${data} to be an array but was not`);
     const ret = new Map(json.map(([line1, col1, line2, col2, id, parent, token, terminal, text]) => {

package/reconstruct/reconstruct.js

@@ -277,7 +277,7 @@ function reconstructParameter(parameter, name, defaultValue, configuration) {
         return plain(`${getLexeme(parameter.name)}=${getLexeme(parameter.defaultValue)}`);
     }
     else if (parameter.defaultValue !== undefined && name.length === 0) {
-        return plain(getLexeme(parameter.defaultValue));
+        return defaultValue ?? [];
     }
     else {
         return name;

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

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

package/slicing/static/slice-call.js

@@ -1,31 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllFunctionCallTargets = getAllFunctionCallTargets;
 exports.sliceForCall = sliceForCall;
 exports.handleReturns = handleReturns;
 const assert_1 = require("../../util/assert");
 const fingerprint_1 = require("./fingerprint");
 const linker_1 = require("../../dataflow/internal/linker");
-const environment_1 = require("../../dataflow/environments/environment");
-const scoping_1 = require("../../dataflow/environments/scoping");
-const overwrite_1 = require("../../dataflow/environments/overwrite");
 const graph_1 = require("../../dataflow/graph/graph");
 const built_in_1 = require("../../dataflow/environments/built-in");
 const resolve_by_name_1 = require("../../dataflow/environments/resolve-by-name");
 const edge_1 = require("../../dataflow/graph/edge");
 const identifier_1 = require("../../dataflow/environments/identifier");
-function retrieveActiveEnvironment(callerInfo, baseEnvironment) {
-    let callerEnvironment = callerInfo.environment;
-    let level = callerEnvironment?.level ?? 0;
-    if (baseEnvironment.level !== level) {
-        while (baseEnvironment.level < level) {
-            baseEnvironment = (0, scoping_1.pushLocalEnvironment)(baseEnvironment);
-        }
-        while (baseEnvironment.level > level) {
-            callerEnvironment = (0, scoping_1.pushLocalEnvironment)(callerEnvironment ?? (0, environment_1.initializeCleanEnvironments)(true));
-            level = callerEnvironment.level;
+const built_in_function_definition_1 = require("../../dataflow/internal/process/functions/call/built-in/built-in-function-definition");
+const static_slicer_1 = require("./static-slicer");
+/**
+ * Returns the function call targets (definitions) by the given caller
+ */
+function getAllFunctionCallTargets(dataflowGraph, callerInfo, baseEnvironment) {
+    // bind with call-local environments during slicing
+    const outgoingEdges = dataflowGraph.get(callerInfo.id, true);
+    (0, assert_1.guard)(outgoingEdges !== undefined, () => `outgoing edges of id: ${callerInfo.id} must be in graph but can not be found, keep in slice to be sure`);
+    // lift baseEnv on the same level
+    const activeEnvironment = (0, built_in_function_definition_1.retrieveActiveEnvironment)(callerInfo.environment, baseEnvironment);
+    const name = callerInfo.name;
+    (0, assert_1.guard)(name !== undefined, () => `name of id: ${callerInfo.id} can not be found in id map`);
+    const functionCallDefs = (0, resolve_by_name_1.resolveByName)(name, activeEnvironment, identifier_1.ReferenceType.Unknown)?.filter(d => d.definedAt !== built_in_1.BuiltIn)?.map(d => d.nodeId) ?? [];
+    for (const [target, outgoingEdge] of outgoingEdges[1].entries()) {
+        if ((0, edge_1.edgeIncludesType)(outgoingEdge.types, edge_1.EdgeType.Calls)) {
+            functionCallDefs.push(target);
         }
     }
-    return (0, overwrite_1.overwriteEnvironment)(baseEnvironment, callerEnvironment);
+    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
+    return [functionCallTargets, activeEnvironment];
 }
 function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironment, queue, dataflowGraph) {
     const valueRoot = (0, graph_1.getReferenceOfArgument)(arg);
@@ -33,20 +39,21 @@ function includeArgumentFunctionCallClosure(arg, baseEnvironment, activeEnvironm
         return;
     }
     const callTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set([valueRoot]), dataflowGraph);
-    linkCallTargets(false, callTargets, baseEnvironment, (0, fingerprint_1.envFingerprint)(baseEnvironment), activeEnvironment, (0, fingerprint_1.envFingerprint)(activeEnvironment), queue);
+    linkCallTargets(false, callTargets, activeEnvironment, (0, fingerprint_1.envFingerprint)(activeEnvironment), queue);
 }
-function linkCallTargets(onlyForSideEffects, functionCallTargets, baseEnvironment, baseEnvPrint, activeEnvironment, activeEnvironmentFingerprint, queue) {
+function linkCallTargets(onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue) {
     for (const functionCallTarget of functionCallTargets) {
         // all those linked within the scopes of other functions are already linked when exiting a function definition
-        for (const openIn of functionCallTarget.subflow.in) {
-            const defs = openIn.name ? (0, resolve_by_name_1.resolveByName)(openIn.name, activeEnvironment, openIn.type) : undefined;
-            if (defs === undefined) {
+        /* for(const openIn of (functionCallTarget as DataflowGraphVertexFunctionDefinition).subflow.in) {
+            // only if the outgoing path does not already have a defined by linkage
+            const defs = openIn.name ? resolveByName(openIn.name, activeEnvironment, openIn.type) : undefined;
+            if(defs === undefined) {
                 continue;
             }
-            for (const def of defs.filter(d => d.nodeId !== built_in_1.BuiltIn)) {
+            for(const def of defs.filter(d => d.nodeId !== BuiltIn)) {
                 queue.add(def.nodeId, baseEnvironment, baseEnvPrint, onlyForSideEffects);
             }
-        }
+        }*/
         for (const exitPoint of functionCallTarget.exitPoints) {
             queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, onlyForSideEffects);
         }
@@ -54,23 +61,9 @@ function linkCallTargets(onlyForSideEffects, functionCallTargets, baseEnvironmen
 }
 /** returns the new threshold hit count */
 function sliceForCall(current, callerInfo, dataflowGraph, queue) {
-    // bind with call-local environments during slicing
-    const outgoingEdges = dataflowGraph.get(callerInfo.id, true);
-    (0, assert_1.guard)(outgoingEdges !== undefined, () => `outgoing edges of id: ${callerInfo.id} must be in graph but can not be found, keep in slice to be sure`);
-    // lift baseEnv on the same level
     const baseEnvironment = current.baseEnvironment;
-    const baseEnvPrint = (0, fingerprint_1.envFingerprint)(baseEnvironment);
-    const activeEnvironment = retrieveActiveEnvironment(callerInfo, baseEnvironment);
+    const [functionCallTargets, activeEnvironment] = getAllFunctionCallTargets(dataflowGraph, callerInfo, current.baseEnvironment);
     const activeEnvironmentFingerprint = (0, fingerprint_1.envFingerprint)(activeEnvironment);
-    const name = callerInfo.name;
-    (0, assert_1.guard)(name !== undefined, () => `name of id: ${callerInfo.id} can not be found in id map`);
-    const functionCallDefs = (0, resolve_by_name_1.resolveByName)(name, activeEnvironment, identifier_1.ReferenceType.Unknown)?.filter(d => d.definedAt !== built_in_1.BuiltIn)?.map(d => d.nodeId) ?? [];
-    for (const [target, outgoingEdge] of outgoingEdges[1].entries()) {
-        if ((0, edge_1.edgeIncludesType)(outgoingEdge.types, edge_1.EdgeType.Calls)) {
-            functionCallDefs.push(target);
-        }
-    }
-    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
     if (functionCallTargets.size === 0) {
         /*
          * if we do not have any call to resolve this function, we have to assume that every function passed is actually called!
@@ -81,10 +74,10 @@ function sliceForCall(current, callerInfo, dataflowGraph, queue) {
         }
         return;
     }
-    linkCallTargets(current.onlyForSideEffects, functionCallTargets, baseEnvironment, baseEnvPrint, activeEnvironment, activeEnvironmentFingerprint, queue);
+    linkCallTargets(current.onlyForSideEffects, functionCallTargets, activeEnvironment, activeEnvironmentFingerprint, queue);
 }
 /** Returns true if we found at least one return edge */
-function handleReturns(queue, currentEdges, baseEnvFingerprint, baseEnvironment) {
+function handleReturns(from, queue, currentEdges, baseEnvFingerprint, baseEnvironment) {
     const e = [...currentEdges.entries()];
     const found = e.filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Returns));
     if (found.length === 0) {
@@ -97,12 +90,8 @@ function handleReturns(queue, currentEdges, baseEnvFingerprint, baseEnvironment)
         if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Reads)) {
             queue.add(target, baseEnvironment, baseEnvFingerprint, false);
         }
-        else if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.Argument)) {
-            queue.potentialArguments.set(target, {
-                id: target,
-                baseEnvironment,
-                onlyForSideEffects: false
-            });
+        else if ((0, edge_1.edgeIncludesType)(edge.types, edge_1.EdgeType.DefinesOnCall | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.Argument)) {
+            (0, static_slicer_1.updatePotentialAddition)(queue, from, target, baseEnvironment);
         }
     }
     return true;

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

@@ -1,7 +1,10 @@
 import type { SliceResult } from './slicer-types';
+import { VisitingQueue } from './visiting-queue';
 import type { DataflowGraph } from '../../dataflow/graph/graph';
 import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { SlicingCriteria } from '../criterion/parse';
+import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
 /**
  * This returns the ids to include in the static backward slice, when slicing with the given seed id's (must be at least one).
@@ -10,7 +13,8 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
- * @param criteria  - The criteras to slice on.
+ * @param criteria  - The criterias to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
 export declare function staticSlicing(graph: DataflowGraph, { idMap }: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;
+export declare function updatePotentialAddition(queue: VisitingQueue, id: NodeId, target: NodeId, baseEnvironment: REnvironmentInformation): void;

package/slicing/static/static-slicer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.slicerLogger = void 0;
 exports.staticSlicing = staticSlicing;
+exports.updatePotentialAddition = updatePotentialAddition;
 const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
 const fingerprint_1 = require("./fingerprint");
@@ -19,7 +20,7 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  *
  * @param graph     - The dataflow graph to conduct the slicing on.
  * @param ast       - The normalized AST of the code (used to get static nesting information of the lexemes in case of control flow dependencies that may have no effect on the slicing scope).
- * @param criteria  - The criteras to slice on.
+ * @param criteria  - The criterias to slice on.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  */
 function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
@@ -71,7 +72,7 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
             if (currentVertex.tag === vertex_1.VertexType.FunctionCall && !currentVertex.onlyBuiltin) {
                 (0, slice_call_1.sliceForCall)(current, currentVertex, graph, queue);
             }
-            const ret = (0, slice_call_1.handleReturns)(queue, currentEdges, baseEnvFingerprint, baseEnvironment);
+            const ret = (0, slice_call_1.handleReturns)(id, queue, currentEdges, baseEnvFingerprint, baseEnvironment);
             if (ret) {
                 continue;
             }
@@ -84,12 +85,8 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
             if (t === 3 /* TraverseEdge.Always */) {
                 queue.add(target, baseEnvironment, baseEnvFingerprint, false);
             }
-            else if (t === 2 /* TraverseEdge.DefinedByOnCall */) {
-                const n = queue.potentialArguments.get(target);
-                if (n) {
-                    queue.add(target, n.baseEnvironment, (0, fingerprint_1.envFingerprint)(n.baseEnvironment), n.onlyForSideEffects);
-                    queue.potentialArguments.delete(target);
-                }
+            else if (t === 2 /* TraverseEdge.OnlyIfBoth */) {
+                updatePotentialAddition(queue, id, target, baseEnvironment);
             }
             else if (t === 1 /* TraverseEdge.SideEffect */) {
                 queue.add(target, baseEnvironment, baseEnvFingerprint, true);
@@ -98,4 +95,21 @@ function staticSlicing(graph, { idMap }, criteria, threshold = 75) {
     }
     return { ...queue.status(), decodedCriteria };
 }
+function updatePotentialAddition(queue, id, target, baseEnvironment) {
+    const n = queue.potentialAdditions.get(target);
+    if (n) {
+        const [addedBy, { baseEnvironment, onlyForSideEffects }] = n;
+        if (addedBy !== id) {
+            queue.add(target, baseEnvironment, (0, fingerprint_1.envFingerprint)(baseEnvironment), onlyForSideEffects);
+            queue.potentialAdditions.delete(target);
+        }
+    }
+    else {
+        queue.potentialAdditions.set(target, [id, {
+                id: target,
+                baseEnvironment,
+                onlyForSideEffects: false
+            }]);
+    }
+}
 //# sourceMappingURL=static-slicer.js.map

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

@@ -4,10 +4,10 @@ import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-i
 export declare class VisitingQueue {
     private readonly threshold;
     private timesHitThreshold;
-    private seen;
-    private idThreshold;
-    private queue;
-    potentialArguments: Map<NodeId, NodeToSlice>;
+    private readonly seen;
+    private readonly idThreshold;
+    private readonly queue;
+    potentialAdditions: Map<NodeId, [NodeId, NodeToSlice]>;
     constructor(threshold: number);
     /**
      * Adds a node to the queue if it has not been seen before.

package/slicing/static/visiting-queue.js

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisitingQueue = void 0;
 const fingerprint_1 = require("./fingerprint");
 const static_slicer_1 = require("./static-slicer");
+const assert_1 = require("../../util/assert");
 class VisitingQueue {
     threshold;
     timesHitThreshold = 0;
     seen = new Map();
     idThreshold = new Map();
     queue = [];
-    // the set of potential arguments holds arguments which may be added if found with the `defined-by-on-call` edge
-    potentialArguments = new Map();
+    // the set of potential additions holds nodes which may be added if a second edge deems them relevant (e.g., found with the `defined-by-on-call` edge)
+    // additionally it holds which node id added the addition so we can separate their inclusion on the structure
+    potentialAdditions = new Map();
     constructor(threshold) {
         this.threshold = threshold;
     }
@@ -48,7 +50,7 @@ class VisitingQueue {
     status() {
         return {
             timesHitThreshold: this.timesHitThreshold,
-            result: new Set(this.seen.values())
+            result: new Set([...this.seen.values()].filter(assert_1.isNotUndefined))
         };
     }
 }

package/statistics/output/print-stats.js

@@ -7,9 +7,10 @@ exports.printFeatureStatisticsEntry = printFeatureStatisticsEntry;
 const ansi_1 = require("../../util/ansi");
 const json_1 = require("../../util/json");
 const feature_1 = require("../features/feature");
+const arrays_1 = require("../../util/arrays");
 function minMaxAvgAndMedian(data) {
     data = data.sort((a, b) => a - b);
-    const sum = data.reduce((a, b) => a + b, 0);
+    const sum = (0, arrays_1.arraySum)(data);
     return {
         sum,
         min: data[0],

package/statistics/summarizer/post-process/histogram.js

@@ -11,6 +11,7 @@ const bimap_1 = require("../../../util/bimap");
 const defaultmap_1 = require("../../../util/defaultmap");
 const assert_1 = require("../../../util/assert");
 const summarizer_1 = require("../../../util/summarizer");
+const arrays_1 = require("../../../util/arrays");
 /**
  * Produces column-wise histogram-information based on a {@link ClusterReport}.
  *
@@ -79,7 +80,7 @@ function histograms2table(histograms, countAsDensity = false) {
     (0, assert_1.guard)(histograms.length > 0, 'there must be at least one histogram to convert to a table');
     const mostBins = guardForLargestBinSize(histograms);
     const header = ['bin', 'from', 'to', ...histograms.map(h => JSON.stringify(h.name))];
-    const sums = histograms.map(h => h.bins.reduce((a, b) => a + b, 0));
+    const sums = histograms.map(h => (0, arrays_1.arraySum)(h.bins));
     const rows = [];
     for (let binIndex = 0; binIndex < mostBins; binIndex++) {
         const row = new Array(histograms.length + 3);

package/statistics/summarizer/post-process/post-process-output.js

@@ -14,6 +14,7 @@ const ansi_1 = require("../../../util/ansi");
 const feature_1 = require("../../features/feature");
 const decorate_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/decorate");
 const file_provider_1 = require("../../output/file-provider");
+const arrays_1 = require("../../../util/arrays");
 /**
  * Post process the collections in a given folder, reducing them in a memory preserving way.
  *
@@ -79,7 +80,7 @@ function printClusterReport(report, limit = 1000) {
     const shortStats = [...report.valueInfoMap.entries()].map(([name, values]) => {
         return {
             name,
-            count: [...values.values()].reduce((a, b) => a + b, 0),
+            count: (0, arrays_1.arraySum)([...values.values()]),
             unique: values.size()
         };
     }).sort((a, b) => b.count - a.count).slice(0, limit);

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

@@ -50,7 +50,7 @@ function postProcessMeta(config, filepath, outputPath, logger, metaFeatureInform
     out.write(`file,successfulParsed,${(0, summarizer_1.summarizedMeasurement2CsvHeader)('processing')},failedRequests,${(0, summarizer_1.summarizedMeasurement2CsvHeader)('line-length')},${(0, summarizer_1.summarizedMeasurement2CsvHeader)('lines')},${(0, summarizer_1.summarizedMeasurement2CsvHeader)('characters')},numberOfNormalizedNodes\n`);
     for (const [file, info] of metaFeatureInformation) {
         // we could retrieve these by summing later as well :thinking: however, this makes it more explicit
-        const characters = (0, arrays_1.sum)(info.stats.lines[0]);
+        const characters = (0, arrays_1.arraySum)(info.stats.lines[0]);
         out.write(`${JSON.stringify(file)},${info.stats.successfulParsed},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(info.stats.processingTimeMs))},`
             + `${info.stats.failedRequests.length},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(info.stats.lines[0]))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)([info.stats.lines[0].length]))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)([characters]))},${info.stats.numberOfNormalizedNodes[0]}\n`);
         fileStatisticsSummary.successfulParsed.push(info.stats.successfulParsed);
@@ -60,8 +60,8 @@ function postProcessMeta(config, filepath, outputPath, logger, metaFeatureInform
         fileStatisticsSummary.characters.push(characters);
         fileStatisticsSummary.numberOfNormalizedNodes.push(info.stats.numberOfNormalizedNodes[0]);
     }
-    out.write(`all,${(0, arrays_1.sum)(fileStatisticsSummary.successfulParsed)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.processingTimeMs))},`
-        + `${(0, arrays_1.sum)(fileStatisticsSummary.failedRequests)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.lines.flat()))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.lines.map(l => l.length)))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.characters))},${(0, arrays_1.sum)(fileStatisticsSummary.numberOfNormalizedNodes)}\n`);
+    out.write(`all,${(0, arrays_1.arraySum)(fileStatisticsSummary.successfulParsed)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.processingTimeMs))},`
+        + `${(0, arrays_1.arraySum)(fileStatisticsSummary.failedRequests)},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.lines.flat()))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.lines.map(l => l.length)))},${(0, summarizer_1.summarizedMeasurement2Csv)((0, summarizer_1.summarizeMeasurement)(fileStatisticsSummary.characters))},${(0, arrays_1.arraySum)(fileStatisticsSummary.numberOfNormalizedNodes)}\n`);
     out.close();
 }
 /**

package/util/arrays.d.ts

@@ -46,7 +46,7 @@ export declare function getUniqueCombinationsOfSize<T>(array: T[], minSize?: num
 /**
  * Returns the sum of all elements in the given array
  */
-export declare function sum(arr: number[]): number;
+export declare function arraySum(arr: readonly number[]): number;
 /**
  * Converts an array into a bag data-structure (in the form of a map mapping the entries/keys to their counts)
  */

package/util/arrays.js

@@ -5,7 +5,7 @@ exports.partitionArray = partitionArray;
 exports.allPermutations = allPermutations;
 exports.partition = partition;
 exports.getUniqueCombinationsOfSize = getUniqueCombinationsOfSize;
-exports.sum = sum;
+exports.arraySum = arraySum;
 exports.array2bag = array2bag;
 exports.arrayEqual = arrayEqual;
 const assert_1 = require("./assert");
@@ -143,7 +143,7 @@ function* getUniqueCombinationsOfSize(array, minSize = 0, maxSize = array.length
 /**
  * Returns the sum of all elements in the given array
  */
-function sum(arr) {
+function arraySum(arr) {
     let sum = 0;
     for (const elem of arr) {
         sum += elem;
@@ -167,7 +167,7 @@ function arrayEqual(a, b) {
     if (a.length !== b.length) {
         return false;
     }
-    for (let i = 0; i < a.length; ++i) {
+    for (let i = 0; i < a.length; i++) {
         if (a[i] !== b[i]) {
             return false;
         }

package/util/assert.d.ts

@@ -6,7 +6,7 @@ export declare function isNotNull<T>(x: T | null): x is T;
 export type GuardMessage = string | (() => string);
 /**
  * @param assertion - will be asserted
- * @param message - if a string, will be used as error message, if a function, will be called to produce the error message (can be used to avoid costly message generations)
+ * @param message - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
  * @throws GuardError - if the assertion fails
  */
 export declare function guard(assertion: boolean | undefined, message?: GuardMessage): asserts assertion;

package/util/assert.js

@@ -6,7 +6,7 @@ exports.isNotUndefined = isNotUndefined;
 exports.isUndefined = isUndefined;
 exports.isNotNull = isNotNull;
 exports.guard = guard;
-/* istanbul ignore next */
+/* v8 ignore next */
 function assertUnreachable(x) {
     throw new Error(`Unexpected object: ${JSON.stringify(x)}`);
 }
@@ -27,10 +27,11 @@ class GuardError extends Error {
 }
 /**
  * @param assertion - will be asserted
- * @param message - if a string, will be used as error message, if a function, will be called to produce the error message (can be used to avoid costly message generations)
+ * @param message - if a string, we will use it as the error message, if it is a function, we will call it to produce the error message (can be used to avoid costly message generations)
  * @throws GuardError - if the assertion fails
  */
 function guard(assertion, message = 'Assertion failed') {
+    /* v8 ignore next 3 */
     if (!assertion) {
         throw new GuardError(typeof message === 'string' ? message : message());
     }

package/util/cfg/cfg.js

@@ -381,9 +381,11 @@ function cfgAccess(access, name, accessors) {
 }
 function cfgUnaryOp(unary, operand) {
     const graph = operand.graph;
-    const result = { ...operand, graph, exitPoints: [unary.info.id] };
     graph.addVertex({ id: unary.info.id, name: unary.type, type: "end-marker" /* CfgVertexType.EndMarker */ });
-    return result;
+    for (const entry of operand.exitPoints) {
+        graph.addEdge(unary.info.id, entry, { label: 'FD' });
+    }
+    return { ...operand, graph, exitPoints: [unary.info.id] };
 }
 function cfgExprList(_node, _grouping, expressions) {
     const result = { graph: new ControlFlowGraph(), breaks: [], nexts: [], returns: [], exitPoints: [], entryPoints: [] };

package/util/mermaid/cfg.js

@@ -16,7 +16,7 @@ function cfgToMermaid(cfg, normalizedAst, prefix = '') {
             output += `    n${id}[${name}]\n`;
         }
         else {
-            output += `    n${id}(( ))\n`;
+            output += String(id).endsWith('-exit') ? `    n${id}((${id}))\n` : `    n${id}[[${id}]]\n`;
         }
     }
     for (const [from, targets] of cfg.graph.edges()) {

package/util/summarizer.js

@@ -27,11 +27,11 @@ function summarizeMeasurement(data, totalNumberOfDataPoints) {
     const min = sorted[0];
     const max = sorted[sorted.length - 1];
     const median = sorted[Math.floor(sorted.length / 2)];
-    const total = (0, arrays_1.sum)(sorted);
+    const total = (0, arrays_1.arraySum)(sorted);
     const length = totalNumberOfDataPoints ?? sorted.length;
     const mean = total / length;
     // sqrt(sum(x-mean)^2 / n)
-    const std = Math.sqrt(sorted.map(x => (x - mean) ** 2).reduce((a, b) => a + b, 0) / length);
+    const std = Math.sqrt((0, arrays_1.arraySum)(sorted.map(x => (x - mean) ** 2)) / length);
     return { min, max, median, mean, std, total };
 }
 //# sourceMappingURL=summarizer.js.map

package/util/version.js

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