@eagleoutice/flowr 1.5.2 → 2.0.1

package/abstract-interpretation/handler/binop/binop.d.ts

@@ -1,9 +1,8 @@
 import type { Handler } from '../handler';
 import type { AINode } from '../../processor';
-import type { BinaryOperatorFlavor, ParentInformation, RBinaryOp } from '../../../r-bridge';
-export type BinOpOperators = {
-    [key in BinaryOperatorFlavor]: (lhs: AINode, rhs: AINode, node: RBinaryOp<ParentInformation>) => AINode;
-};
+import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RBinaryOp } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-binary-op';
+export type BinaryOpProcessor = (lhs: AINode, rhs: AINode, node: RBinaryOp<ParentInformation>) => AINode;
 export declare class BinOp implements Handler<AINode> {
     readonly node: RBinaryOp<ParentInformation>;
     lhs: AINode | undefined;

package/abstract-interpretation/handler/binop/binop.js

@@ -12,7 +12,7 @@ class BinOp {
         this.node = node;
     }
     getName() {
-        return `Bin Op (${this.node.flavor})`;
+        return `Bin Op (${this.node.operator})`;
     }
     enter() {
         processor_1.aiLogger.trace(`Entered ${this.getName()}`);
@@ -21,7 +21,9 @@ class BinOp {
         processor_1.aiLogger.trace(`Exited ${this.getName()}`);
         (0, assert_1.guard)(this.lhs !== undefined, `No LHS found for assignment ${this.node.info.id}`);
         (0, assert_1.guard)(this.rhs !== undefined, `No RHS found for assignment ${this.node.info.id}`);
-        return operators_1.operators[this.node.flavor](this.lhs, this.rhs, this.node);
+        const processor = operators_1.operators[this.node.operator];
+        (0, assert_1.guard)(processor !== undefined, `No processor found for binary operator ${this.node.operator}`);
+        return processor(this.lhs, this.rhs, this.node);
     }
     next(node) {
         processor_1.aiLogger.trace(`${this.getName()} received`);

package/abstract-interpretation/handler/binop/operators.d.ts

@@ -1,2 +1,2 @@
-import type { BinOpOperators } from './binop';
-export declare const operators: BinOpOperators;
+import type { BinaryOpProcessor } from './binop';
+export declare const operators: Record<string, BinaryOpProcessor>;

package/abstract-interpretation/handler/binop/operators.js

@@ -1,42 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.operators = void 0;
-const assert_1 = require("../../../util/assert");
 const domain_1 = require("../../domain");
 exports.operators = {
-    'assignment': (lhs, rhs, node) => {
+    '<-': (lhs, rhs, node) => {
         return {
             id: lhs.id,
             domain: rhs.domain,
             astNode: node.lhs,
         };
     },
-    'arithmetic': (lhs, rhs, node) => {
-        switch (node.operator) {
-            case '+':
-                return {
-                    id: lhs.id,
-                    domain: (0, domain_1.addDomains)(lhs.domain, rhs.domain),
-                    astNode: node,
-                };
-            case '-':
-                return {
-                    id: lhs.id,
-                    domain: (0, domain_1.subtractDomains)(lhs.domain, rhs.domain),
-                    astNode: node,
-                };
-            default:
-                (0, assert_1.guard)(false, `Unknown binary operator ${node.operator}`);
-        }
-    },
-    'logical': () => {
-        (0, assert_1.guard)(false, 'Not implemented yet');
-    },
-    'model formula': () => {
-        (0, assert_1.guard)(false, 'Not implemented yet');
-    },
-    'comparison': () => {
-        (0, assert_1.guard)(false, 'Not implemented yet');
+    '+': (lhs, rhs, node) => {
+        return {
+            id: lhs.id,
+            domain: (0, domain_1.addDomains)(lhs.domain, rhs.domain),
+            astNode: node,
+        };
     },
+    '-': (lhs, rhs, node) => {
+        return {
+            id: lhs.id,
+            domain: (0, domain_1.subtractDomains)(lhs.domain, rhs.domain),
+            astNode: node,
+        };
+    }
 };
 //# sourceMappingURL=operators.js.map

package/abstract-interpretation/processor.d.ts

@@ -1,6 +1,7 @@
-import type { DataflowInformation } from '../dataflow/internal/info';
-import type { NodeId, NormalizedAst, ParentInformation, RNodeWithParent } from '../r-bridge';
+import type { DataflowInformation } from '../dataflow/info';
 import { Domain } from './domain';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { NormalizedAst, ParentInformation, RNodeWithParent } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 export declare const aiLogger: import("tslog").Logger<import("tslog").ILogObj>;
 export interface AINode {
     readonly id: NodeId;

package/abstract-interpretation/processor.js

@@ -4,10 +4,10 @@ exports.runAbstractInterpretation = exports.aiLogger = void 0;
 const cfg_1 = require("../util/cfg/cfg");
 const visitor_1 = require("../util/cfg/visitor");
 const assert_1 = require("../util/assert");
-const dataflow_1 = require("../dataflow");
 const binop_1 = require("./handler/binop/binop");
 const domain_1 = require("./domain");
 const log_1 = require("../util/log");
+const edge_1 = require("../dataflow/graph/edge");
 exports.aiLogger = log_1.log.getSubLogger({ name: 'abstract-interpretation' });
 class Stack {
     backingStore = [];
@@ -30,7 +30,7 @@ function getDomainOfDfgChild(node, dfg, nodeMap) {
     (0, assert_1.guard)(dfgNode !== undefined, `No DFG-Node found with ID ${node}`);
     const [_, children] = dfgNode;
     const ids = Array.from(children.entries())
-        .filter(([_, edge]) => edge.types.has(dataflow_1.EdgeType.Reads))
+        .filter(([_, edge]) => (0, edge_1.edgeIncludesType)(edge.types, 1 /* EdgeType.Reads */))
         .map(([id, _]) => id);
     const domains = [];
     for (const id of ids) {

package/benchmark/slicer.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Provides a top-level slicer that can be used to slice code *and* retrieve stats.
+ * @module
+ */
+import type { MergeableRecord } from '../util/objects';
+import type { DataflowInformation } from '../dataflow/info';
+import type { SliceResult } from '../slicing/static/slicer-types';
+import type { ReconstructionResult } from '../reconstruct/reconstruct';
+import type { PerSliceStats, SlicerStats } from './stats/stats';
+import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { SlicingCriteria } from '../slicing/criterion/parse';
+import type { RParseRequestFromFile, RParseRequestFromText } from '../r-bridge/retriever';
+import type { SlicingCriteriaFilter } from '../slicing/criterion/collect-all';
+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 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 PipelineExecutor} using the {@link DEFAULT_SLICING_PIPELINE}.
+ */
+export declare class BenchmarkSlicer {
+    /** Measures all data 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 dataflow;
+    private normalizedAst;
+    private totalStopwatch;
+    private finished;
+    private pipeline;
+    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,214 @@
+"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 stopwatch_1 = require("./stopwatch");
+const fs_1 = __importDefault(require("fs"));
+const log_1 = require("../util/log");
+const pipeline_executor_1 = require("../core/pipeline-executor");
+const assert_1 = require("../util/assert");
+const strings_1 = require("../util/strings");
+const shell_1 = require("../r-bridge/shell");
+const default_pipelines_1 = require("../core/steps/pipeline/default-pipelines");
+const retriever_1 = require("../r-bridge/retriever");
+const collect_1 = require("../r-bridge/lang-4.x/ast/model/collect");
+const collect_all_1 = require("../slicing/criterion/collect-all");
+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 PipelineExecutor} using the {@link DEFAULT_SLICING_PIPELINE}.
+ */
+class BenchmarkSlicer {
+    /** Measures all data recorded *once* per slicer (complete setup up to the dataflow graph creation) */
+    commonMeasurements = new stopwatch_1.Measurements();
+    perSliceMeasurements = new Map();
+    shell;
+    stats;
+    loadedXml;
+    dataflow;
+    normalizedAst;
+    totalStopwatch;
+    finished = false;
+    // Yes, this is unclean, but we know that we assign the executor during the initialization and this saves us from having to check for nullability every time
+    pipeline = null;
+    constructor() {
+        this.totalStopwatch = this.commonMeasurements.start('total');
+        this.shell = this.commonMeasurements.measure('initialize R session', () => new shell_1.RShell());
+    }
+    /**
+     * 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');
+        this.pipeline = new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_SLICING_PIPELINE, {
+            shell: this.shell,
+            request: { ...request },
+            criterion: []
+        });
+        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.pipeline.switchToRequestStage();
+        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, retriever_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, collect_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.pipeline.updateRequest({ criterion: 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.pipeline.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.hasVertex(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.pipeline.nextStep(expectedStep));
+        return result;
+    }
+    async measureSliceStep(expectedStep, measure, keyToMeasure) {
+        const { result } = await measure.measureAsync(keyToMeasure, () => this.pipeline.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, collect_all_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
+        };
+    }
+    /**
+   * 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/print.d.ts

@@ -0,0 +1,7 @@
+import type { SummarizedSlicerStats, UltimateSlicerStats } from '../summarizer/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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ultimateStats2String = exports.stats2string = void 0;
+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')}
+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'))}
+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

@@ -0,0 +1,42 @@
+import type { SingleSlicingCriterion, SlicingCriteria } from '../../slicing/criterion/parse';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ReconstructionResult } from '../../reconstruct/reconstruct';
+import type { RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge/retriever';
+export declare const CommonSlicerMeasurements: readonly ["initialize R session", "retrieve AST from R code", "normalize R AST", "produce dataflow information", "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

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