@eagleoutice/flowr 1.4.1 → 1.5.0

package/benchmark/slicer.d.ts

@@ -1,101 +0,0 @@
-/**
- * Provides a top-level slicer that can be used to slice code *and* retrieve stats.
- * @module
- */
-import type { NormalizedAst, RParseRequestFromFile, RParseRequestFromText } from '../r-bridge';
-import type { DataflowInformation } from '../dataflow/internal/info';
-import type { SlicingCriteria, SlicingCriteriaFilter, SliceResult, ReconstructionResult } from '../slicing';
-import type { PerSliceStats, SlicerStats } from './stats';
-import type { 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 ai;
-    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

@@ -1,225 +0,0 @@
-"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;
-    ai;
-    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.ai = await this.measureCommonStep('ai', 'run abstract interpretation');
-        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

@@ -1,10 +0,0 @@
-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

@@ -1,27 +0,0 @@
-"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

@@ -1,7 +0,0 @@
-import type { 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;

package/benchmark/stats/print.js

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ultimateStats2String = exports.stats2string = void 0;
-/**
- * This module is tasked with processing the results of the benchmarking (see {@link SummarizedSlicerStats}).
- * @module
- */
-const assert_1 = require("../../util/assert");
-const padSize = 15;
-function pad(string) {
-    return String(string).padStart(padSize, ' ');
-}
-function divWithRest(dividend, divisor) {
-    return [dividend / divisor, dividend % divisor];
-}
-function formatNanoseconds(nanoseconds) {
-    if (nanoseconds < 0) {
-        return '??';
-    }
-    const [seconds, rest] = divWithRest(typeof nanoseconds === 'number' ? BigInt(Math.round(nanoseconds)) : nanoseconds, BigInt(1e9));
-    const [milliseconds, remainingNanoseconds] = divWithRest(rest, BigInt(1e6));
-    const secondsStr = seconds > 0 ? `${String(seconds).padStart(2, '0')}.` : '';
-    const millisecondsStr = seconds > 0 ? `${String(milliseconds).padStart(3, '0')}:` : `${String(milliseconds)}:`;
-    const nanoStr = String(remainingNanoseconds).padEnd(3, '0').substring(0, 3);
-    const unit = seconds === 0n ? 'ms' : ' s'; /* space for padding */
-    return pad(`${secondsStr}${millisecondsStr}${nanoStr}${unit}`);
-}
-function print(measurements, key) {
-    const time = measurements.get(key);
-    (0, assert_1.guard)(time !== undefined, `Measurement for ${JSON.stringify(key)} not found`);
-    return formatNanoseconds(time);
-}
-function formatSummarizedTimeMeasure(measure) {
-    if (measure === undefined) {
-        return '??';
-    }
-    return `${formatNanoseconds(measure.min)} - ${formatNanoseconds(measure.max)} (median: ${formatNanoseconds(measure.median)}, mean: ${formatNanoseconds(measure.mean)}, std: ${formatNanoseconds(measure.std)})`;
-}
-function roundTo(num, digits = 4) {
-    const factor = Math.pow(10, digits);
-    return Math.round(num * factor) / factor;
-}
-function asPercentage(num) {
-    if (isNaN(num)) {
-        return '??%';
-    }
-    return pad(`${roundTo(num * 100, 3)}%`);
-}
-function asFloat(num) {
-    return pad(roundTo(num));
-}
-function formatSummarizedMeasure(measure, fmt = asFloat) {
-    if (measure === undefined) {
-        return '??';
-    }
-    return `${fmt(measure.min)} - ${fmt(measure.max)} (median: ${fmt(measure.median)}, mean: ${fmt(measure.mean)}, std: ${fmt(measure.std)})`;
-}
-function printSummarizedMeasurements(stats, key) {
-    const measure = stats.measurements.get(key);
-    (0, assert_1.guard)(measure !== undefined, `Measurement for ${JSON.stringify(key)} not found`);
-    return formatSummarizedTimeMeasure(measure);
-}
-function printCountSummarizedMeasurements(stats) {
-    const range = `${stats.min} - ${stats.max}`.padStart(padSize, ' ');
-    return `${range} (median: ${stats.median}, mean: ${stats.mean}, std: ${stats.std})`;
-}
-/**
- * Converts the given stats to a human-readable string.
- * You may have to {@link summarizeSlicerStats | summarize} the stats first.
- */
-function stats2string(stats) {
-    let result = `
-Request: ${JSON.stringify(stats.request)}
-Shell init time:              ${print(stats.commonMeasurements, 'initialize R session')}
-Retrieval of token map:       ${print(stats.commonMeasurements, 'retrieve token map')}
-AST retrieval:                ${print(stats.commonMeasurements, 'retrieve AST from R code')}
-AST normalization:            ${print(stats.commonMeasurements, 'normalize R AST')}
-Dataflow creation:            ${print(stats.commonMeasurements, 'produce dataflow information')}
-
-Slicing summary for ${stats.perSliceMeasurements.numberOfSlices} slice${stats.perSliceMeasurements.numberOfSlices !== 1 ? 's' : ''}:`;
-    if (stats.perSliceMeasurements.numberOfSlices > 0) {
-        result += `
-  Total:                      ${printSummarizedMeasurements(stats.perSliceMeasurements, 'total')}
-  Slice creation:             ${printSummarizedMeasurements(stats.perSliceMeasurements, 'static slicing')}
-  Reconstruction:             ${printSummarizedMeasurements(stats.perSliceMeasurements, 'reconstruct code')}
-  Used Slice Criteria Sizes:  ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceCriteriaSizes)}
-  Result Slice Sizes:   
-    Number of lines:                     ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.lines)}
-    Number of characters:                ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.characters)}
-    Number of non whitespace characters: ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.nonWhitespaceCharacters)}
-    Number of auto selected:             ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.autoSelected)}
-    Number of R tokens:                  ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.tokens)}
-    Normalized R tokens:                 ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.normalizedTokens)}
-    Number of dataflow nodes:            ${printCountSummarizedMeasurements(stats.perSliceMeasurements.sliceSize.dataflowNodes)}
-`;
-    }
-    return `${result}
-Shell close:                  ${print(stats.commonMeasurements, 'close R session')}
-Total:                        ${print(stats.commonMeasurements, 'total')}
-
-Input:
-  Number of lines:                     ${pad(stats.input.numberOfLines)}
-  Number of characters:                ${pad(stats.input.numberOfCharacters)}
-  Number of non whitespace characters: ${pad(stats.input.numberOfNonWhitespaceCharacters)}
-  Number of tokens:                    ${pad(stats.input.numberOfRTokens)}
-  Normalized R tokens:                 ${pad(stats.input.numberOfNormalizedTokens)}
-
-Dataflow:
-  Number of nodes:            ${pad(stats.dataflow.numberOfNodes)}
-  Number of edges:            ${pad(stats.dataflow.numberOfEdges)}
-  Number of calls:            ${pad(stats.dataflow.numberOfCalls)}
-  Number of function defs:    ${pad(stats.dataflow.numberOfFunctionDefinitions)}`;
-}
-exports.stats2string = stats2string;
-function ultimateStats2String(stats) {
-    // Used Slice Criteria Sizes:  ${formatSummarizedMeasure(stats.perSliceMeasurements.sliceCriteriaSizes)}
-    return `
-Summarized: ${stats.totalRequests} requests and ${stats.totalSlices} slices
-Shell init time:              ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('initialize R session'))}
-Retrieval of token map:       ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('retrieve token map'))}
-AST retrieval:                ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('retrieve AST from R code'))}
-AST normalization:            ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('normalize R AST'))}
-Dataflow creation:            ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('produce dataflow information'))}
-
-Slice summary for:
-  Total:                      ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('total'))}
-  Slice creation:             ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('static slicing'))}
-  Reconstruction:             ${formatSummarizedTimeMeasure(stats.perSliceMeasurements.get('reconstruct code'))}
-  Failed to Re-Parse:         ${pad(stats.failedToRepParse)}/${stats.totalSlices}
-  Times hit Threshold:        ${pad(stats.timesHitThreshold)}/${stats.totalSlices} 
-  Reductions (reduced by x%):   
-    Number of lines:                     ${formatSummarizedMeasure(stats.reduction.numberOfLines, asPercentage)}
-    Number of lines no auto:             ${formatSummarizedMeasure(stats.reduction.numberOfLinesNoAutoSelection, asPercentage)}
-    Number of characters:                ${formatSummarizedMeasure(stats.reduction.numberOfCharacters, asPercentage)}
-    Number of non whitespace characters: ${formatSummarizedMeasure(stats.reduction.numberOfNonWhitespaceCharacters, asPercentage)}
-    Number of R tokens:                  ${formatSummarizedMeasure(stats.reduction.numberOfRTokens, asPercentage)}
-    Normalized R tokens:                 ${formatSummarizedMeasure(stats.reduction.numberOfNormalizedTokens, asPercentage)}
-    Number of dataflow nodes:            ${formatSummarizedMeasure(stats.reduction.numberOfDataflowNodes, asPercentage)}
-
-Shell close:                  ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('close R session'))}
-Total:                        ${formatSummarizedTimeMeasure(stats.commonMeasurements.get('total'))}
-
-Input:
-  Number of lines:                     ${formatSummarizedMeasure(stats.input.numberOfLines)}
-  Number of characters:                ${formatSummarizedMeasure(stats.input.numberOfCharacters)}
-  Number of non whitespace characters: ${formatSummarizedMeasure(stats.input.numberOfNonWhitespaceCharacters)}
-  Number of tokens:                    ${formatSummarizedMeasure(stats.input.numberOfRTokens)}
-  Normalized R tokens:                 ${formatSummarizedMeasure(stats.input.numberOfNormalizedTokens)}
-
-Dataflow:
-  Number of nodes:            ${formatSummarizedMeasure(stats.dataflow.numberOfNodes)}
-  Number of edges:            ${formatSummarizedMeasure(stats.dataflow.numberOfEdges)}
-  Number of calls:            ${formatSummarizedMeasure(stats.dataflow.numberOfCalls)}
-  Number of function defs:    ${formatSummarizedMeasure(stats.dataflow.numberOfFunctionDefinitions)}`;
-}
-exports.ultimateStats2String = ultimateStats2String;
-//# sourceMappingURL=print.js.map

package/benchmark/stats/stats.d.ts

@@ -1,41 +0,0 @@
-import type { SingleSlicingCriterion, SlicingCriteria } from '../../slicing';
-import type { NodeId, RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge';
-import type { ReconstructionResult } from '../../slicing';
-export declare const CommonSlicerMeasurements: readonly ["initialize R session", "inject home path", "ensure installation of xmlparsedata", "retrieve token map", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "run abstract interpretation", "close R session", "total"];
-export type CommonSlicerMeasurements = typeof CommonSlicerMeasurements[number];
-export declare const PerSliceMeasurements: readonly ["static slicing", "reconstruct code", "total"];
-export type PerSliceMeasurements = typeof PerSliceMeasurements[number];
-export type ElapsedTime = bigint;
-export interface PerSliceStats {
-    measurements: Map<PerSliceMeasurements, ElapsedTime>;
-    slicingCriteria: {
-        criterion: SingleSlicingCriterion;
-        id: NodeId;
-    }[];
-    reconstructedCode: ReconstructionResult;
-    numberOfDataflowNodesSliced: number;
-    timesHitThreshold: number;
-}
-export interface SlicerStatsInput<T = number> {
-    numberOfLines: T;
-    numberOfCharacters: T;
-    numberOfNonWhitespaceCharacters: T;
-    numberOfRTokens: T;
-    numberOfNormalizedTokens: T;
-}
-export interface SlicerStatsDataflow<T = number> {
-    numberOfNodes: T;
-    numberOfEdges: T;
-    numberOfCalls: T;
-    numberOfFunctionDefinitions: T;
-}
-/**
- * The statistics that are collected by the {@link BenchmarkSlicer} and used for benchmarking.
- */
-export interface SlicerStats {
-    commonMeasurements: Map<CommonSlicerMeasurements, ElapsedTime>;
-    perSliceMeasurements: Map<SlicingCriteria, PerSliceStats>;
-    request: RParseRequestFromFile | RParseRequestFromText;
-    input: SlicerStatsInput;
-    dataflow: SlicerStatsDataflow;
-}

package/benchmark/stats/stats.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerSliceMeasurements = exports.CommonSlicerMeasurements = void 0;
-exports.CommonSlicerMeasurements = ['initialize R session', 'inject home path', 'ensure installation of xmlparsedata', 'retrieve token map', 'retrieve AST from R code', 'normalize R AST', 'produce dataflow information', 'run abstract interpretation', 'close R session', 'total'];
-exports.PerSliceMeasurements = ['static slicing', 'reconstruct code', 'total'];
-//# sourceMappingURL=stats.js.map

package/benchmark/stopwatch.d.ts

@@ -1,35 +0,0 @@
-export interface IStoppableStopwatch {
-    /** Stop the given stopwatch. */
-    stop(): void;
-}
-/**
- * Allows to measure keys of type `T` with a `Stopwatch`.
- *
- * Measure with {@link start}, {@link measure} or {@link measureAsync}, retrieve the final measurements with {@link get}.
- */
-export declare class Measurements<T> {
-    private measurements;
-    /**
-   * Start a timer for the given key, and guards that this is the first time this key is started.
-   * Call {@link IStoppableStopwatch#stop} on the returned stopwatch to stop the timer.
-   */
-    start(key: T): IStoppableStopwatch;
-    /**
-   * Automatically call {@link Measurements#start | start} and the corresponding stop to measure the execution time of the given function.
-   * @see {@link measureAsync}
-   */
-    measure<Out>(key: T, fn: () => Out): Out;
-    /**
-   * Similar to {@link measure}, but await the promise as part of the measurement
-   *
-     * @param key - The key to write the resulting measurement to
-     * @param fn  - The function to measure
-     *
-   * @see measure
-   */
-    measureAsync<Out>(key: T, fn: () => Promise<Out>): Promise<Out>;
-    /**
-   * Retrieve all measure-results, requires that all stop-watches that have been started have also been stopped.
-   */
-    get(): Map<T, bigint>;
-}