@eagleoutice/flowr 1.3.14 → 1.4.2

package/README.md

@@ -1,12 +1,12 @@
 [![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)
+[![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) [![Marketplace](https://badgen.net/vs-marketplace/v/code-inspect.vscode-flowr)](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr)
 
 
-*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`).
+*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`). It is available as a [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr) and as a [docker image](https://hub.docker.com/r/eagleoutice/flowr).
 
 ## ⭐ 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):
+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. For Visual Studio Code, please see the [marketplace entry](https://marketplace.visualstudio.com/items?itemName=code-inspect.vscode-flowr). With docker 🐳️, the following line should be enough (and drop you directly into the REPL):
 
 ```shell
 docker run -it --rm eagleoutice/flowr

package/abstract-interpretation/domain.d.ts

@@ -0,0 +1,27 @@
+interface IntervalBound {
+    readonly value: number;
+    readonly inclusive: boolean;
+}
+export declare class Interval {
+    readonly min: IntervalBound;
+    readonly max: IntervalBound;
+    constructor(min: IntervalBound, max: IntervalBound);
+    toString(): string;
+}
+export declare class Domain {
+    private readonly _intervals;
+    private constructor();
+    static bottom(): Domain;
+    static fromIntervals(intervals: Interval[] | Set<Interval>): Domain;
+    static fromScalar(n: number): Domain;
+    get intervals(): Set<Interval>;
+    private set intervals(value);
+    addInterval(interval: Interval): void;
+    toString(): string;
+}
+export declare function doIntervalsOverlap(interval1: Interval, interval2: Interval): boolean;
+export declare function unifyDomains(domains: Domain[]): Domain;
+export declare function unifyOverlappingIntervals(intervals: Interval[]): Interval[];
+export declare function addDomains(domain1: Domain, domain2: Domain): Domain;
+export declare function subtractDomains(domain1: Domain, domain2: Domain): Domain;
+export {};

package/abstract-interpretation/domain.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subtractDomains = exports.addDomains = exports.unifyOverlappingIntervals = exports.unifyDomains = exports.doIntervalsOverlap = exports.Domain = exports.Interval = void 0;
+const assert_1 = require("../util/assert");
+class Interval {
+    min;
+    max;
+    constructor(min, max) {
+        this.min = min;
+        this.max = max;
+        (0, assert_1.guard)(min.value <= max.value, () => `The interval ${this.toString()} has a minimum that is greater than its maximum`);
+        (0, assert_1.guard)(min.value !== max.value || (min.inclusive === max.inclusive), `The bound ${min.value} cannot be in- and exclusive at the same time`);
+    }
+    toString() {
+        return `${this.min.inclusive ? '[' : '('}${this.min.value}, ${this.max.value}${this.max.inclusive ? ']' : ')'}`;
+    }
+}
+exports.Interval = Interval;
+class Domain {
+    _intervals;
+    constructor(intervals = []) {
+        this._intervals = new Set(unifyOverlappingIntervals(intervals));
+    }
+    static bottom() {
+        return new Domain();
+    }
+    static fromIntervals(intervals) {
+        return new Domain(Array.from(intervals));
+    }
+    static fromScalar(n) {
+        return new Domain([new Interval({ value: n, inclusive: true }, { value: n, inclusive: true })]);
+    }
+    get intervals() {
+        return this._intervals;
+    }
+    set intervals(intervals) {
+        this._intervals.clear();
+        for (const interval of intervals) {
+            this._intervals.add(interval);
+        }
+    }
+    addInterval(interval) {
+        this.intervals = unifyOverlappingIntervals([...this.intervals, interval]);
+    }
+    toString() {
+        return `{${Array.from(this.intervals).join(', ')}}`;
+    }
+}
+exports.Domain = Domain;
+function compareIntervals(compareType, interval1, interval2) {
+    const diff = interval1.value - interval2.value;
+    if (diff !== 0 || compareType === 2 /* CompareType.IgnoreInclusivity */) {
+        return diff;
+    }
+    switch (compareType) {
+        case 0 /* CompareType.Min */:
+            return Number(!interval1.inclusive) - Number(!interval2.inclusive);
+        case 1 /* CompareType.Max */:
+            return Number(interval1.inclusive) - Number(interval2.inclusive);
+        default:
+            (0, assert_1.assertUnreachable)(compareType);
+    }
+}
+function compareIntervalsByTheirMinimum(interval1, interval2) {
+    return compareIntervals(0 /* CompareType.Min */, interval1.min, interval2.min);
+}
+function compareIntervalsByTheirMaximum(interval1, interval2) {
+    return compareIntervals(1 /* CompareType.Max */, interval1.max, interval2.max);
+}
+function doIntervalsOverlap(interval1, interval2) {
+    const diff1 = compareIntervals(2 /* CompareType.IgnoreInclusivity */, interval1.max, interval2.min);
+    const diff2 = compareIntervals(2 /* CompareType.IgnoreInclusivity */, interval2.max, interval1.min);
+    // If one interval ends before the other starts, they don't overlap
+    if (diff1 < 0 || diff2 < 0) {
+        return false;
+    }
+    // If their end and start are equal, they only overlap if both are inclusive
+    if (diff1 === 0) {
+        return interval1.max.inclusive && interval2.min.inclusive;
+    }
+    if (diff2 === 0) {
+        return interval2.max.inclusive && interval1.min.inclusive;
+    }
+    return true;
+}
+exports.doIntervalsOverlap = doIntervalsOverlap;
+function unifyDomains(domains) {
+    const unifiedIntervals = unifyOverlappingIntervals(domains.flatMap(domain => Array.from(domain.intervals)));
+    return Domain.fromIntervals(unifiedIntervals);
+}
+exports.unifyDomains = unifyDomains;
+function unifyOverlappingIntervals(intervals) {
+    if (intervals.length === 0) {
+        return [];
+    }
+    const sortedIntervals = intervals.sort(compareIntervalsByTheirMinimum);
+    const unifiedIntervals = [];
+    let currentInterval = sortedIntervals[0];
+    for (const nextInterval of sortedIntervals) {
+        if (doIntervalsOverlap(currentInterval, nextInterval)) {
+            const intervalWithEarlierStart = compareIntervalsByTheirMinimum(currentInterval, nextInterval) < 0 ? currentInterval : nextInterval;
+            const intervalWithLaterEnd = compareIntervalsByTheirMaximum(currentInterval, nextInterval) > 0 ? currentInterval : nextInterval;
+            currentInterval = new Interval(intervalWithEarlierStart.min, intervalWithLaterEnd.max);
+        }
+        else {
+            unifiedIntervals.push(currentInterval);
+            currentInterval = nextInterval;
+        }
+    }
+    unifiedIntervals.push(currentInterval);
+    return unifiedIntervals;
+}
+exports.unifyOverlappingIntervals = unifyOverlappingIntervals;
+function addDomains(domain1, domain2) {
+    const intervals = new Set();
+    for (const interval1 of domain1.intervals) {
+        for (const interval2 of domain2.intervals) {
+            intervals.add(new Interval({
+                value: interval1.min.value + interval2.min.value,
+                inclusive: interval1.min.inclusive && interval2.min.inclusive
+            }, {
+                value: interval1.max.value + interval2.max.value,
+                inclusive: interval1.max.inclusive && interval2.max.inclusive
+            }));
+        }
+    }
+    return Domain.fromIntervals(intervals);
+}
+exports.addDomains = addDomains;
+function subtractDomains(domain1, domain2) {
+    const intervals = new Set();
+    for (const interval1 of domain1.intervals) {
+        for (const interval2 of domain2.intervals) {
+            intervals.add(new Interval({
+                value: interval1.min.value - interval2.max.value,
+                inclusive: interval1.min.inclusive && interval2.max.inclusive
+            }, {
+                value: interval1.max.value - interval2.min.value,
+                inclusive: interval1.max.inclusive && interval2.min.inclusive
+            }));
+        }
+    }
+    return Domain.fromIntervals(intervals);
+}
+exports.subtractDomains = subtractDomains;
+//# sourceMappingURL=domain.js.map

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

@@ -0,0 +1,16 @@
+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;
+};
+export declare class BinOp implements Handler<AINode> {
+    readonly node: RBinaryOp<ParentInformation>;
+    lhs: AINode | undefined;
+    rhs: AINode | undefined;
+    constructor(node: RBinaryOp<ParentInformation>);
+    getName(): string;
+    enter(): void;
+    exit(): AINode;
+    next(node: AINode): void;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinOp = void 0;
+const processor_1 = require("../../processor");
+const assert_1 = require("../../../util/assert");
+const operators_1 = require("./operators");
+class BinOp {
+    node;
+    lhs;
+    rhs;
+    constructor(node) {
+        this.node = node;
+    }
+    getName() {
+        return `Bin Op (${this.node.flavor})`;
+    }
+    enter() {
+        processor_1.aiLogger.trace(`Entered ${this.getName()}`);
+    }
+    exit() {
+        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);
+    }
+    next(node) {
+        processor_1.aiLogger.trace(`${this.getName()} received`);
+        if (this.lhs === undefined) {
+            this.lhs = node;
+        }
+        else if (this.rhs === undefined) {
+            this.rhs = node;
+        }
+        else {
+            (0, assert_1.guard)(false, `BinOp ${this.node.info.id} already has both LHS and RHS`);
+        }
+    }
+}
+exports.BinOp = BinOp;
+//# sourceMappingURL=binop.js.map

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

@@ -0,0 +1,2 @@
+import type { BinOpOperators } from './binop';
+export declare const operators: BinOpOperators;

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

@@ -0,0 +1,42 @@
+"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) => {
+        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');
+    },
+};
+//# sourceMappingURL=operators.js.map

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

@@ -0,0 +1,6 @@
+export interface Handler<ValueType> {
+    getName: () => string;
+    enter: () => void;
+    exit: () => ValueType;
+    next: (value: ValueType) => void;
+}

package/abstract-interpretation/handler/handler.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=handler.js.map

package/abstract-interpretation/processor.d.ts

@@ -0,0 +1,10 @@
+import type { DataflowInformation } from '../dataflow/internal/info';
+import type { NodeId, NormalizedAst, ParentInformation, RNodeWithParent } from '../r-bridge';
+import { Domain } from './domain';
+export declare const aiLogger: import("tslog").Logger<import("tslog").ILogObj>;
+export interface AINode {
+    readonly id: NodeId;
+    readonly domain: Domain;
+    readonly astNode: RNodeWithParent<ParentInformation>;
+}
+export declare function runAbstractInterpretation(ast: NormalizedAst, dfg: DataflowInformation): DataflowInformation;

package/abstract-interpretation/processor.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.aiLogger = log_1.log.getSubLogger({ name: 'abstract-interpretation' });
+class Stack {
+    backingStore = [];
+    size() {
+        return this.backingStore.length;
+    }
+    peek() {
+        return this.backingStore[this.size() - 1];
+    }
+    pop() {
+        return this.backingStore.pop();
+    }
+    push(item) {
+        this.backingStore.push(item);
+        return item;
+    }
+}
+function getDomainOfDfgChild(node, dfg, nodeMap) {
+    const dfgNode = dfg.graph.get(node);
+    (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))
+        .map(([id, _]) => id);
+    const domains = [];
+    for (const id of ids) {
+        const domain = nodeMap.get(id)?.domain;
+        (0, assert_1.guard)(domain !== undefined, `No domain found for ID ${id}`);
+        domains.push(domain);
+    }
+    return (0, domain_1.unifyDomains)(domains);
+}
+function runAbstractInterpretation(ast, dfg) {
+    const cfg = (0, cfg_1.extractCFG)(ast);
+    const operationStack = new Stack();
+    const nodeMap = new Map();
+    (0, visitor_1.visitCfg)(cfg, (node, _) => {
+        const astNode = ast.idMap.get(node.id);
+        if (astNode?.type === "RBinaryOp" /* RType.BinaryOp */) {
+            operationStack.push(new binop_1.BinOp(astNode)).enter();
+        }
+        else if (astNode?.type === "RSymbol" /* RType.Symbol */) {
+            operationStack.peek()?.next({
+                id: astNode.info.id,
+                domain: getDomainOfDfgChild(node.id, dfg, nodeMap),
+                astNode: astNode,
+            });
+        }
+        else if (astNode?.type === "RNumber" /* RType.Number */) {
+            const num = astNode.content.num;
+            operationStack.peek()?.next({
+                id: astNode.info.id,
+                domain: domain_1.Domain.fromScalar(num),
+                astNode: astNode,
+            });
+        }
+        else if (node.type === "end-marker" /* CfgVertexType.EndMarker */) {
+            const operation = operationStack.pop();
+            if (operation === undefined) {
+                return;
+            }
+            const operationResult = operation.exit();
+            (0, assert_1.guard)(!nodeMap.has(operationResult.id), `Domain for ID ${operationResult.id} already exists`);
+            nodeMap.set(operationResult.id, operationResult);
+            operationStack.peek()?.next(operationResult);
+        }
+        else {
+            exports.aiLogger.warn(`Unknown node type ${node.type}`);
+        }
+    });
+    return dfg;
+}
+exports.runAbstractInterpretation = runAbstractInterpretation;
+//# sourceMappingURL=processor.js.map

package/benchmark/slicer.d.ts

@@ -2,11 +2,11 @@
  * 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';
+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.
@@ -15,8 +15,6 @@ export declare const benchmarkLogger: import("tslog").Logger<import("tslog").ILo
 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 */
@@ -52,8 +50,8 @@ export declare class BenchmarkSlicer {
     private readonly shell;
     private stats;
     private loadedXml;
-    private tokenMap;
     private dataflow;
+    private ai;
     private normalizedAst;
     private totalStopwatch;
     private finished;

package/benchmark/slicer.js

@@ -29,12 +29,12 @@ exports.benchmarkLogger = log_1.log.getSubLogger({ name: 'benchmark' });
 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;
+    perSliceMeasurements = new Map();
     shell;
     stats;
     loadedXml;
-    tokenMap;
     dataflow;
+    ai;
     normalizedAst;
     totalStopwatch;
     finished = false;
@@ -43,7 +43,6 @@ class BenchmarkSlicer {
     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.
@@ -51,19 +50,11 @@ class BenchmarkSlicer {
      */
     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
-            },
+            request: { ...request },
             stepOfInterest: core_1.LAST_STEP,
-            criterion: [],
-            tokenMap: this.tokenMap
+            criterion: []
         });
         this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code');
         this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST');
@@ -208,8 +199,7 @@ class BenchmarkSlicer {
             stats: this.stats,
             parse: this.loadedXml,
             dataflow: this.dataflow,
-            normalize: this.normalizedAst,
-            tokenMap: this.tokenMap,
+            normalize: this.normalizedAst
         };
     }
     /**

package/benchmark/stats/print.d.ts

@@ -1,4 +1,4 @@
-import { SummarizedSlicerStats, UltimateSlicerStats } from '../../util/summarizer/benchmark/data';
+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.

package/benchmark/stats/print.js

@@ -72,7 +72,6 @@ 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')}
@@ -117,7 +116,6 @@ function ultimateStats2String(stats) {
     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'))}

package/benchmark/stats/stats.d.ts

@@ -1,7 +1,6 @@
-import { SingleSlicingCriterion, SlicingCriteria } from '../../slicing';
-import { NodeId, RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge';
-import { 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", "close R session", "total"];
+import type { ReconstructionResult, SingleSlicingCriterion, SlicingCriteria } from '../../slicing';
+import type { NodeId, RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge';
+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];

package/benchmark/stats/stats.js

@@ -1,6 +1,6 @@
 "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', 'close R session', 'total'];
+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

package/cli/benchmark-app.d.ts

@@ -6,4 +6,5 @@ export interface BenchmarkCliOptions {
     slice: string;
     parallel: number;
     limit?: number;
+    runs?: number;
 }

package/cli/benchmark-app.js

@@ -9,6 +9,7 @@ const parallel_1 = require("../util/parallel");
 const assert_1 = require("../util/assert");
 const fs_1 = __importDefault(require("fs"));
 const common_1 = require("./common");
+const path_1 = __importDefault(require("path"));
 const options = (0, common_1.processCommandLineArgs)('benchmark', [], {
     subtitle: 'Slice given files with additional benchmark information',
     examples: [
@@ -21,15 +22,17 @@ if (options.input.length === 0) {
     process.exit(0);
 }
 (0, assert_1.guard)(options.slice === 'all' || options.slice === 'no', 'slice must be either all or no');
+(0, assert_1.guard)(options.runs === undefined || options.runs > 0, 'runs must be greater than zero');
 function removeIfExists(summarizedRaw) {
     if (fs_1.default.existsSync(summarizedRaw)) {
         console.log(`Removing existing ${summarizedRaw}`);
-        fs_1.default.unlinkSync(summarizedRaw);
+        fs_1.default.rmSync(summarizedRaw, { recursive: true });
     }
 }
 async function benchmark() {
     removeIfExists(options.output);
-    console.log(`Writing output continuously to ${options.output}`);
+    fs_1.default.mkdirSync(options.output);
+    console.log(`Storing output in ${options.output}`);
     console.log(`Using ${options.parallel} parallel executors`);
     // we do not use the limit argument to be able to pick the limit randomly
     const files = [];
@@ -43,10 +46,22 @@ async function benchmark() {
     }
     const limit = options.limit ?? files.length;
     const verboseAdd = options.verbose ? ['--verbose'] : [];
-    const pool = new parallel_1.LimitedThreadPool(`${__dirname}/benchmark-helper-app`, files.map(f => [f.content, '--output', options.output, '--slice', options.slice, ...verboseAdd]), limit, options.parallel);
-    await pool.run();
-    const stats = pool.getStats();
-    console.log(`Benchmarked ${stats.counter} files, skipped ${stats.skipped.length} files due to errors`);
+    const args = files.map((f, i) => [
+        '--input', f.content,
+        '--file-id', `${i}`,
+        '--output', path_1.default.join(options.output, `${path_1.default.parse(f.content).name}.json`),
+        '--slice', options.slice, ...verboseAdd
+    ]);
+    const runs = options.runs ?? 1;
+    for (let i = 1; i <= runs; i++) {
+        console.log(`Run ${i} of ${runs}`);
+        const pool = new parallel_1.LimitedThreadPool(`${__dirname}/benchmark-helper-app`, 
+        // we reverse here "for looks", since the helper pops from the end, and we want file ids to be ascending :D
+        args.map(a => [...a, '--run-num', `${i}`]).reverse(), limit, options.parallel);
+        await pool.run();
+        const stats = pool.getStats();
+        console.log(`Run ${i} of ${runs}: Benchmarked ${stats.counter} files, skipped ${stats.skipped.length} files due to errors`);
+    }
 }
 void benchmark();
 //# sourceMappingURL=benchmark-app.js.map

package/cli/benchmark-helper-app.d.ts

@@ -2,6 +2,8 @@ export interface SingleBenchmarkCliOptions {
     verbose: boolean;
     help: boolean;
     input?: string;
+    'file-id'?: number;
+    'run-num'?: number;
     slice: string;
     output?: string;
 }