@eagleoutice/flowr 1.3.11

package/README.md

@@ -0,0 +1,27 @@
+[![flowR logo](https://raw.githubusercontent.com/wiki/Code-Inspect/flowr/img/flowR.png)](https://github.com/Code-Inspect/flowr/wiki)\
+[![QA (and potentially deploy)](https://github.com/Code-Inspect/flowr/actions/workflows/qa.yaml/badge.svg)](https://github.com/Code-Inspect/flowr/actions/workflows/qa.yaml) [![codecov](https://codecov.io/gh/Code-Inspect/flowr/graph/badge.svg)](https://codecov.io/gh/Code-Inspect/flowr) [![Docker Image Version (latest semver)](https://img.shields.io/docker/v/eagleoutice/flowr?logo=docker&logoColor=white&label=dockerhub)](https://hub.docker.com/r/eagleoutice/flowr) [![latest tag](https://badgen.net/github/tag/Code-Inspect/flowr?label=latest&color=purple)](https://github.com/Code-Inspect/flowr/releases/latest)
+
+
+*flowR* is a static [dataflow analyzer](https://en.wikipedia.org/wiki/Data-flow_analysis) and [program slicer](https://github.com/Code-Inspect/flowr/wiki/Terminology#program-slice) for the [*R*](https://www.r-project.org/) programming language (currently tested for versions `4.x`).
+
+## ⭐ Getting Started
+
+To get started with _flowR_, please check out the [Overview](https://github.com/Code-Inspect/flowr/wiki/Overview). The [Setup](https://github.com/Code-Inspect/flowr/wiki/Setup) wiki page explains how you can download and setup _flowR_ on your system. With docker 🐳️, the following line should be enough (and drop you directly into the REPL):
+
+```shell
+docker run -it --rm eagleoutice/flowr
+ ```
+
+
+## 📜 More Information
+
+For more details, see the [wiki pages](https://github.com/Code-Inspect/flowr/wiki) and the deployed [code documentation](https://code-inspect.github.io/flowr/doc/).
+
+We welcome every contribution! Please check out the [contributing guidelines](https://github.com/Code-Inspect/flowr/tree/main/.github/CONTRIBUTING.md) for more information.
+
+----
+
+*flowr* is actively developed by *Florian Sihler* (contact at: <florian.sihler@uni-ulm.de>) under the
+[GPLv3 License](LICENSE).
+
+----

package/benchmark/benchmark-slicer.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Provides a top-level slicer that can be used to slice code *and* retrieve stats.
+ * @module
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkSlicer = exports.benchmarkLogger = void 0;
+const r_bridge_1 = require("../r-bridge");
+const stopwatch_1 = require("./stopwatch");
+const assert_1 = require("../util/assert");
+const slicing_1 = require("../slicing");
+const fs_1 = __importDefault(require("fs"));
+const log_1 = require("../util/log");
+const core_1 = require("../core");
+const strings_1 = require("../util/strings");
+exports.benchmarkLogger = log_1.log.getSubLogger({ name: 'benchmark' });
+/**
+ * A slicer that can be used to slice exactly one file (multiple times).
+ * It holds its own {@link RShell} instance, maintains a cached dataflow and keeps measurements.
+ *
+ * Make sure to call {@link init} to initialize the slicer, before calling {@link slice}.
+ * After slicing, call {@link finish} to close the R session and retrieve the stats.
+ *
+ * @note Under the hood, the benchmark slicer maintains a {@link SteppingSlicer}.
+ */
+class BenchmarkSlicer {
+    /** Measures all data that is recorded *once* per slicer (complete setup up to the dataflow graph creation) */
+    commonMeasurements = new stopwatch_1.Measurements();
+    perSliceMeasurements = new Map;
+    shell;
+    stats;
+    loadedXml;
+    tokenMap;
+    dataflow;
+    normalizedAst;
+    totalStopwatch;
+    finished = false;
+    // Yes this is dirty, but we know that we assign the stepper during the initialization and this saves us from having to check for nullability every time
+    stepper = null;
+    constructor() {
+        this.totalStopwatch = this.commonMeasurements.start('total');
+        this.shell = this.commonMeasurements.measure('initialize R session', () => new r_bridge_1.RShell());
+        this.commonMeasurements.measure('inject home path', () => this.shell.tryToInjectHomeLibPath());
+    }
+    /**
+     * Initialize the slicer on the given request.
+     * Can only be called once for each instance.
+     */
+    async init(request) {
+        (0, assert_1.guard)(this.stats === undefined, 'cannot initialize the slicer twice');
+        await this.commonMeasurements.measureAsync('ensure installation of xmlparsedata', () => this.shell.ensurePackageInstalled('xmlparsedata', true));
+        this.tokenMap = await this.commonMeasurements.measureAsync('retrieve token map', 
+        // with this being the first time, there is no preexisting caching!
+        () => this.shell.tokenMap());
+        this.stepper = new core_1.SteppingSlicer({
+            shell: this.shell,
+            request: {
+                ...request,
+                ensurePackageInstalled: true
+            },
+            stepOfInterest: core_1.LAST_STEP,
+            criterion: [],
+            tokenMap: this.tokenMap
+        });
+        this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code');
+        this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
+        this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information');
+        this.stepper.switchToSliceStage();
+        await this.calculateStatsAfterInit(request);
+    }
+    async calculateStatsAfterInit(request) {
+        const loadedContent = request.request === 'text' ? request.content : fs_1.default.readFileSync(request.content, 'utf-8');
+        // retrieve number of R tokens - flowr_parsed should still contain the last parsed code
+        const numberOfRTokens = await (0, r_bridge_1.retrieveNumberOfRTokensOfLastParse)(this.shell);
+        (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');
+        // collect dataflow graph size
+        const vertices = [...this.dataflow.graph.vertices(true)];
+        let numberOfEdges = 0;
+        let numberOfCalls = 0;
+        let numberOfDefinitions = 0;
+        for (const [n, info] of vertices) {
+            const outgoingEdges = this.dataflow.graph.outgoingEdges(n);
+            numberOfEdges += outgoingEdges?.size ?? 0;
+            if (info.tag === 'function-call') {
+                numberOfCalls++;
+            }
+            else if (info.tag === 'function-definition') {
+                numberOfDefinitions++;
+            }
+        }
+        this.stats = {
+            commonMeasurements: new Map(),
+            perSliceMeasurements: this.perSliceMeasurements,
+            request,
+            input: {
+                numberOfLines: loadedContent.split('\n').length,
+                numberOfCharacters: loadedContent.length,
+                numberOfNonWhitespaceCharacters: (0, strings_1.withoutWhitespace)(loadedContent).length,
+                numberOfRTokens: numberOfRTokens,
+                numberOfNormalizedTokens: [...(0, r_bridge_1.collectAllIds)(this.normalizedAst.ast)].length
+            },
+            dataflow: {
+                numberOfNodes: [...this.dataflow.graph.vertices(true)].length,
+                numberOfEdges: numberOfEdges,
+                numberOfCalls: numberOfCalls,
+                numberOfFunctionDefinitions: numberOfDefinitions
+            }
+        };
+    }
+    /**
+   * Slice for the given {@link SlicingCriteria}.
+   * @see SingleSlicingCriterion
+   *
+   * @returns The per slice stats retrieved for this slicing criteria
+   */
+    async slice(...slicingCriteria) {
+        exports.benchmarkLogger.trace(`try to slice for criteria ${JSON.stringify(slicingCriteria)}`);
+        this.guardActive();
+        (0, assert_1.guard)(!this.perSliceMeasurements.has(slicingCriteria), 'do not slice the same criteria combination twice');
+        const measurements = new stopwatch_1.Measurements();
+        const stats = {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            measurements: undefined,
+            slicingCriteria: [],
+            numberOfDataflowNodesSliced: 0,
+            timesHitThreshold: 0,
+            reconstructedCode: {
+                code: '',
+                autoSelected: 0
+            }
+        };
+        this.perSliceMeasurements.set(slicingCriteria, stats);
+        this.stepper.updateCriterion(slicingCriteria);
+        const totalStopwatch = measurements.start('total');
+        const slicedOutput = await this.measureSliceStep('slice', measurements, 'static slicing');
+        stats.slicingCriteria = slicedOutput.decodedCriteria;
+        stats.reconstructedCode = await this.measureSliceStep('reconstruct', measurements, 'reconstruct code');
+        totalStopwatch.stop();
+        exports.benchmarkLogger.debug(`Produced code for ${JSON.stringify(slicingCriteria)}: ${stats.reconstructedCode.code}`);
+        const results = this.stepper.getResults(false);
+        if (exports.benchmarkLogger.settings.minLevel >= 3 /* LogLevel.Info */) {
+            exports.benchmarkLogger.info(`mapped slicing criteria: ${slicedOutput.decodedCriteria.map(c => {
+                const node = results.normalize.idMap.get(c.id);
+                return `\n-   id: ${c.id}, location: ${JSON.stringify(node?.location)}, lexeme: ${JSON.stringify(node?.lexeme)}`;
+            }).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.hasNode(id, false)).length;
+        stats.timesHitThreshold = slicedOutput.timesHitThreshold;
+        stats.measurements = measurements.get();
+        return {
+            stats,
+            slice: slicedOutput,
+            code: stats.reconstructedCode
+        };
+    }
+    /** Bridging the gap between the new internal and the old names for the benchmarking */
+    async measureCommonStep(expectedStep, keyToMeasure) {
+        const { result } = await this.commonMeasurements.measureAsync(keyToMeasure, () => this.stepper.nextStep(expectedStep));
+        return result;
+    }
+    async measureSliceStep(expectedStep, measure, keyToMeasure) {
+        const { result } = await measure.measureAsync(keyToMeasure, () => this.stepper.nextStep(expectedStep));
+        return result;
+    }
+    guardActive() {
+        (0, assert_1.guard)(this.stats !== undefined && !this.finished, 'need to call init before, and can not do after finish!');
+    }
+    /**
+   * Call {@link slice} for all slicing criteria that match the given filter.
+   * See {@link collectAllSlicingCriteria} for details.
+   * <p>
+   * the `report` function will be called *before* each individual slice is performed.
+   *
+   * @returns The number of slices that were produced
+   *
+   * @see collectAllSlicingCriteria
+   * @see SlicingCriteriaFilter
+   */
+    async sliceForAll(filter, report = () => { }) {
+        this.guardActive();
+        let count = 0;
+        const allCriteria = [...(0, slicing_1.collectAllSlicingCriteria)(this.normalizedAst.ast, filter)];
+        for (const slicingCriteria of allCriteria) {
+            report(count, allCriteria.length, allCriteria);
+            await this.slice(...slicingCriteria);
+            count++;
+        }
+        return count;
+    }
+    /**
+   * Retrieves the final stats and closes the shell session.
+   * Can be called multiple times to retrieve the stored stats, but will only close the session once (the first time).
+   */
+    finish() {
+        (0, assert_1.guard)(this.stats !== undefined, 'need to call init before finish');
+        if (!this.finished) {
+            this.commonMeasurements.measure('close R session', () => this.shell.close());
+            this.totalStopwatch.stop();
+            this.finished = true;
+        }
+        this.stats.commonMeasurements = this.commonMeasurements.get();
+        return {
+            stats: this.stats,
+            parse: this.loadedXml,
+            dataflow: this.dataflow,
+            normalize: this.normalizedAst,
+            tokenMap: this.tokenMap,
+        };
+    }
+    /**
+   * Only call in case of an error - if the session must be closed and the benchmark itself is to be considered failed/dead.
+   */
+    ensureSessionClosed() {
+        this.shell.close();
+    }
+}
+exports.BenchmarkSlicer = BenchmarkSlicer;
+//# sourceMappingURL=benchmark-slicer.js.map

package/benchmark/index.d.ts

@@ -0,0 +1,3 @@
+export * from './stats';
+export * from './slicer';
+export * from './stopwatch';

package/benchmark/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./stats"), exports);
+__exportStar(require("./slicer"), exports);
+__exportStar(require("./stopwatch"), exports);
+//# sourceMappingURL=index.js.map

package/benchmark/slicer.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Provides a top-level slicer that can be used to slice code *and* retrieve stats.
+ * @module
+ */
+import { NormalizedAst, RParseRequestFromFile, RParseRequestFromText } from '../r-bridge';
+import { DataflowInformation } from '../dataflow/internal/info';
+import { SlicingCriteria, SlicingCriteriaFilter, SliceResult, ReconstructionResult } from '../slicing';
+import { PerSliceStats, SlicerStats } from './stats';
+import { MergeableRecord } from '../util/objects';
+export declare const benchmarkLogger: import("tslog").Logger<import("tslog").ILogObj>;
+/**
+ * Returns the stats but also the result of all setup steps (parsing, normalization, and the dataflow analysis) during the slicing.
+ * This is useful for debugging and visualizing the slicing process.
+ */
+export interface BenchmarkSlicerStats extends MergeableRecord {
+    /** the measurements obtained during the benchmark */
+    stats: SlicerStats;
+    /** the used token map when translating what was parsed from R */
+    tokenMap: Record<string, string>;
+    /** the initial and unmodified AST produced by the R side/the 'parse' step */
+    parse: string;
+    /** the normalized AST produced by the 'normalization' step, including its parent decoration */
+    normalize: NormalizedAst;
+    /** the dataflow graph produced by the 'dataflow' step */
+    dataflow: DataflowInformation;
+}
+/**
+ * Additionally to {@link BenchmarkSlicerStats}, this contains the results of a *single* slice.
+ * In other words, it holds the results of the slice and reconstruct steps.
+ */
+export interface BenchmarkSingleSliceStats extends MergeableRecord {
+    /** the measurements obtained during the single slice */
+    stats: PerSliceStats;
+    /** the result of the 'slice' step */
+    slice: SliceResult;
+    /** the final code, as the result of the 'reconstruct' step */
+    code: ReconstructionResult;
+}
+/**
+ * A slicer that can be used to slice exactly one file (multiple times).
+ * It holds its own {@link RShell} instance, maintains a cached dataflow and keeps measurements.
+ *
+ * Make sure to call {@link init} to initialize the slicer, before calling {@link slice}.
+ * After slicing, call {@link finish} to close the R session and retrieve the stats.
+ *
+ * @note Under the hood, the benchmark slicer maintains a {@link SteppingSlicer}.
+ */
+export declare class BenchmarkSlicer {
+    /** Measures all data that is recorded *once* per slicer (complete setup up to the dataflow graph creation) */
+    private readonly commonMeasurements;
+    private readonly perSliceMeasurements;
+    private readonly shell;
+    private stats;
+    private loadedXml;
+    private tokenMap;
+    private dataflow;
+    private normalizedAst;
+    private totalStopwatch;
+    private finished;
+    private stepper;
+    constructor();
+    /**
+     * Initialize the slicer on the given request.
+     * Can only be called once for each instance.
+     */
+    init(request: RParseRequestFromFile | RParseRequestFromText): Promise<void>;
+    private calculateStatsAfterInit;
+    /**
+   * Slice for the given {@link SlicingCriteria}.
+   * @see SingleSlicingCriterion
+   *
+   * @returns The per slice stats retrieved for this slicing criteria
+   */
+    slice(...slicingCriteria: SlicingCriteria): Promise<BenchmarkSingleSliceStats>;
+    /** Bridging the gap between the new internal and the old names for the benchmarking */
+    private measureCommonStep;
+    private measureSliceStep;
+    private guardActive;
+    /**
+   * Call {@link slice} for all slicing criteria that match the given filter.
+   * See {@link collectAllSlicingCriteria} for details.
+   * <p>
+   * the `report` function will be called *before* each individual slice is performed.
+   *
+   * @returns The number of slices that were produced
+   *
+   * @see collectAllSlicingCriteria
+   * @see SlicingCriteriaFilter
+   */
+    sliceForAll(filter: SlicingCriteriaFilter, report?: (current: number, total: number, allCriteria: SlicingCriteria[]) => void): Promise<number>;
+    /**
+   * Retrieves the final stats and closes the shell session.
+   * Can be called multiple times to retrieve the stored stats, but will only close the session once (the first time).
+   */
+    finish(): BenchmarkSlicerStats;
+    /**
+   * Only call in case of an error - if the session must be closed and the benchmark itself is to be considered failed/dead.
+   */
+    ensureSessionClosed(): void;
+}

package/benchmark/slicer.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Provides a top-level slicer that can be used to slice code *and* retrieve stats.
+ * @module
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BenchmarkSlicer = exports.benchmarkLogger = void 0;
+const r_bridge_1 = require("../r-bridge");
+const stopwatch_1 = require("./stopwatch");
+const assert_1 = require("../util/assert");
+const slicing_1 = require("../slicing");
+const fs_1 = __importDefault(require("fs"));
+const log_1 = require("../util/log");
+const core_1 = require("../core");
+const strings_1 = require("../util/strings");
+exports.benchmarkLogger = log_1.log.getSubLogger({ name: 'benchmark' });
+/**
+ * A slicer that can be used to slice exactly one file (multiple times).
+ * It holds its own {@link RShell} instance, maintains a cached dataflow and keeps measurements.
+ *
+ * Make sure to call {@link init} to initialize the slicer, before calling {@link slice}.
+ * After slicing, call {@link finish} to close the R session and retrieve the stats.
+ *
+ * @note Under the hood, the benchmark slicer maintains a {@link SteppingSlicer}.
+ */
+class BenchmarkSlicer {
+    /** Measures all data that is recorded *once* per slicer (complete setup up to the dataflow graph creation) */
+    commonMeasurements = new stopwatch_1.Measurements();
+    perSliceMeasurements = new Map;
+    shell;
+    stats;
+    loadedXml;
+    tokenMap;
+    dataflow;
+    normalizedAst;
+    totalStopwatch;
+    finished = false;
+    // Yes this is dirty, but we know that we assign the stepper during the initialization and this saves us from having to check for nullability every time
+    stepper = null;
+    constructor() {
+        this.totalStopwatch = this.commonMeasurements.start('total');
+        this.shell = this.commonMeasurements.measure('initialize R session', () => new r_bridge_1.RShell());
+        this.commonMeasurements.measure('inject home path', () => this.shell.tryToInjectHomeLibPath());
+    }
+    /**
+     * Initialize the slicer on the given request.
+     * Can only be called once for each instance.
+     */
+    async init(request) {
+        (0, assert_1.guard)(this.stats === undefined, 'cannot initialize the slicer twice');
+        await this.commonMeasurements.measureAsync('ensure installation of xmlparsedata', () => this.shell.ensurePackageInstalled('xmlparsedata', true));
+        this.tokenMap = await this.commonMeasurements.measureAsync('retrieve token map', 
+        // with this being the first time, there is no preexisting caching!
+        () => this.shell.tokenMap());
+        this.stepper = new core_1.SteppingSlicer({
+            shell: this.shell,
+            request: {
+                ...request,
+                ensurePackageInstalled: true
+            },
+            stepOfInterest: core_1.LAST_STEP,
+            criterion: [],
+            tokenMap: this.tokenMap
+        });
+        this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code');
+        this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
+        this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information');
+        this.stepper.switchToSliceStage();
+        await this.calculateStatsAfterInit(request);
+    }
+    async calculateStatsAfterInit(request) {
+        const loadedContent = request.request === 'text' ? request.content : fs_1.default.readFileSync(request.content, 'utf-8');
+        // retrieve number of R tokens - flowr_parsed should still contain the last parsed code
+        const numberOfRTokens = await (0, r_bridge_1.retrieveNumberOfRTokensOfLastParse)(this.shell);
+        (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');
+        // collect dataflow graph size
+        const vertices = [...this.dataflow.graph.vertices(true)];
+        let numberOfEdges = 0;
+        let numberOfCalls = 0;
+        let numberOfDefinitions = 0;
+        for (const [n, info] of vertices) {
+            const outgoingEdges = this.dataflow.graph.outgoingEdges(n);
+            numberOfEdges += outgoingEdges?.size ?? 0;
+            if (info.tag === 'function-call') {
+                numberOfCalls++;
+            }
+            else if (info.tag === 'function-definition') {
+                numberOfDefinitions++;
+            }
+        }
+        this.stats = {
+            commonMeasurements: new Map(),
+            perSliceMeasurements: this.perSliceMeasurements,
+            request,
+            input: {
+                numberOfLines: loadedContent.split('\n').length,
+                numberOfCharacters: loadedContent.length,
+                numberOfNonWhitespaceCharacters: (0, strings_1.withoutWhitespace)(loadedContent).length,
+                numberOfRTokens: numberOfRTokens,
+                numberOfNormalizedTokens: [...(0, r_bridge_1.collectAllIds)(this.normalizedAst.ast)].length
+            },
+            dataflow: {
+                numberOfNodes: [...this.dataflow.graph.vertices(true)].length,
+                numberOfEdges: numberOfEdges,
+                numberOfCalls: numberOfCalls,
+                numberOfFunctionDefinitions: numberOfDefinitions
+            }
+        };
+    }
+    /**
+   * Slice for the given {@link SlicingCriteria}.
+   * @see SingleSlicingCriterion
+   *
+   * @returns The per slice stats retrieved for this slicing criteria
+   */
+    async slice(...slicingCriteria) {
+        exports.benchmarkLogger.trace(`try to slice for criteria ${JSON.stringify(slicingCriteria)}`);
+        this.guardActive();
+        (0, assert_1.guard)(!this.perSliceMeasurements.has(slicingCriteria), 'do not slice the same criteria combination twice');
+        const measurements = new stopwatch_1.Measurements();
+        const stats = {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            measurements: undefined,
+            slicingCriteria: [],
+            numberOfDataflowNodesSliced: 0,
+            timesHitThreshold: 0,
+            reconstructedCode: {
+                code: '',
+                autoSelected: 0
+            }
+        };
+        this.perSliceMeasurements.set(slicingCriteria, stats);
+        this.stepper.updateCriterion(slicingCriteria);
+        const totalStopwatch = measurements.start('total');
+        const slicedOutput = await this.measureSliceStep('slice', measurements, 'static slicing');
+        stats.slicingCriteria = slicedOutput.decodedCriteria;
+        stats.reconstructedCode = await this.measureSliceStep('reconstruct', measurements, 'reconstruct code');
+        totalStopwatch.stop();
+        exports.benchmarkLogger.debug(`Produced code for ${JSON.stringify(slicingCriteria)}: ${stats.reconstructedCode.code}`);
+        const results = this.stepper.getResults(false);
+        if (exports.benchmarkLogger.settings.minLevel >= 3 /* LogLevel.Info */) {
+            exports.benchmarkLogger.info(`mapped slicing criteria: ${slicedOutput.decodedCriteria.map(c => {
+                const node = results.normalize.idMap.get(c.id);
+                return `\n-   id: ${c.id}, location: ${JSON.stringify(node?.location)}, lexeme: ${JSON.stringify(node?.lexeme)}`;
+            }).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.hasNode(id, false)).length;
+        stats.timesHitThreshold = slicedOutput.timesHitThreshold;
+        stats.measurements = measurements.get();
+        return {
+            stats,
+            slice: slicedOutput,
+            code: stats.reconstructedCode
+        };
+    }
+    /** Bridging the gap between the new internal and the old names for the benchmarking */
+    async measureCommonStep(expectedStep, keyToMeasure) {
+        const { result } = await this.commonMeasurements.measureAsync(keyToMeasure, () => this.stepper.nextStep(expectedStep));
+        return result;
+    }
+    async measureSliceStep(expectedStep, measure, keyToMeasure) {
+        const { result } = await measure.measureAsync(keyToMeasure, () => this.stepper.nextStep(expectedStep));
+        return result;
+    }
+    guardActive() {
+        (0, assert_1.guard)(this.stats !== undefined && !this.finished, 'need to call init before, and can not do after finish!');
+    }
+    /**
+   * Call {@link slice} for all slicing criteria that match the given filter.
+   * See {@link collectAllSlicingCriteria} for details.
+   * <p>
+   * the `report` function will be called *before* each individual slice is performed.
+   *
+   * @returns The number of slices that were produced
+   *
+   * @see collectAllSlicingCriteria
+   * @see SlicingCriteriaFilter
+   */
+    async sliceForAll(filter, report = () => { }) {
+        this.guardActive();
+        let count = 0;
+        const allCriteria = [...(0, slicing_1.collectAllSlicingCriteria)(this.normalizedAst.ast, filter)];
+        for (const slicingCriteria of allCriteria) {
+            report(count, allCriteria.length, allCriteria);
+            await this.slice(...slicingCriteria);
+            count++;
+        }
+        return count;
+    }
+    /**
+   * Retrieves the final stats and closes the shell session.
+   * Can be called multiple times to retrieve the stored stats, but will only close the session once (the first time).
+   */
+    finish() {
+        (0, assert_1.guard)(this.stats !== undefined, 'need to call init before finish');
+        if (!this.finished) {
+            this.commonMeasurements.measure('close R session', () => this.shell.close());
+            this.totalStopwatch.stop();
+            this.finished = true;
+        }
+        this.stats.commonMeasurements = this.commonMeasurements.get();
+        return {
+            stats: this.stats,
+            parse: this.loadedXml,
+            dataflow: this.dataflow,
+            normalize: this.normalizedAst,
+            tokenMap: this.tokenMap,
+        };
+    }
+    /**
+   * Only call in case of an error - if the session must be closed and the benchmark itself is to be considered failed/dead.
+   */
+    ensureSessionClosed() {
+        this.shell.close();
+    }
+}
+exports.BenchmarkSlicer = BenchmarkSlicer;
+//# sourceMappingURL=slicer.js.map

package/benchmark/stats/index.d.ts

@@ -0,0 +1,10 @@
+export * from './print';
+export * from './stats';
+export * from '../../util/summarizer/benchmark/summarizer';
+export { UltimateSlicerStats } from '../../util/summarizer/benchmark/data';
+export { SummarizedPerSliceStats } from '../../util/summarizer/benchmark/data';
+export { Reduction } from '../../util/summarizer/benchmark/data';
+export { SummarizedSlicerStats } from '../../util/summarizer/benchmark/data';
+export { summarizeSummarizedMeasurement } from '../../util/summarizer/benchmark/first-phase/process';
+export { summarizeMeasurement } from '../../util/summarizer/benchmark/first-phase/process';
+export { summarizeSlicerStats } from '../../util/summarizer/benchmark/first-phase/process';

package/benchmark/stats/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeSlicerStats = exports.summarizeMeasurement = exports.summarizeSummarizedMeasurement = void 0;
+__exportStar(require("./print"), exports);
+__exportStar(require("./stats"), exports);
+__exportStar(require("../../util/summarizer/benchmark/summarizer"), exports);
+var process_1 = require("../../util/summarizer/benchmark/first-phase/process");
+Object.defineProperty(exports, "summarizeSummarizedMeasurement", { enumerable: true, get: function () { return process_1.summarizeSummarizedMeasurement; } });
+var process_2 = require("../../util/summarizer/benchmark/first-phase/process");
+Object.defineProperty(exports, "summarizeMeasurement", { enumerable: true, get: function () { return process_2.summarizeMeasurement; } });
+var process_3 = require("../../util/summarizer/benchmark/first-phase/process");
+Object.defineProperty(exports, "summarizeSlicerStats", { enumerable: true, get: function () { return process_3.summarizeSlicerStats; } });
+//# sourceMappingURL=index.js.map

package/benchmark/stats/print.d.ts

@@ -0,0 +1,7 @@
+import { SummarizedSlicerStats, UltimateSlicerStats } from '../../util/summarizer/benchmark/data';
+/**
+ * Converts the given stats to a human-readable string.
+ * You may have to {@link summarizeSlicerStats | summarize} the stats first.
+ */
+export declare function stats2string(stats: SummarizedSlicerStats): string;
+export declare function ultimateStats2String(stats: UltimateSlicerStats): string;