@eagleoutice/flowr 1.3.11 → 1.3.13

package/cli/common/scripts-info.d.ts

@@ -20,5 +20,5 @@ export interface HelperScriptInformation extends BaseScriptInformation {
     masterScripts: string[];
 }
 export type ScriptInformation = MasterScriptInformation | HelperScriptInformation;
-export declare const scripts: Record<"slicer" | "benchmark" | "summarizer" | "export-quads" | "stats" | "stats-helper" | "benchmark-helper", ScriptInformation>;
+export declare const scripts: Record<"slicer" | "benchmark" | "stats" | "summarizer" | "export-quads" | "stats-helper" | "benchmark-helper", ScriptInformation>;
 export {};

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "1.3.11",
+  "version": "1.3.13",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
-  "main": "dist/src/flowr.js",
   "types": "dist/src/index.d.ts",
   "repository": {
     "type": "git",
@@ -337,7 +336,6 @@
     "@types/n-readlines": "^1.0.6",
     "@types/n3": "^1.16.4",
     "@types/object-hash": "^3.0.6",
-    "@types/semver": "^7.5.6",
     "@types/tmp": "^0.2.6",
     "@types/xml2js": "^0.4.14",
     "@typescript-eslint/eslint-plugin": "^6.13.2",
@@ -355,7 +353,6 @@
     "mocha-multi-reporters": "^1.5.1",
     "nyc": "^15.1.0",
     "release-it": "^17.0.1",
-    "ts-essentials": "^9.4.1",
     "ts-node": "^10.9.2",
     "typedoc": "^0.25.4",
     "typedoc-plugin-missing-exports": "^2.1.0",
@@ -364,6 +361,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
+    "@types/semver": "^7.5.6",
     "@types/tar": "^6.1.10",
     "@xmldom/xmldom": "^0.8.10",
     "command-line-args": "^5.2.1",
@@ -377,6 +375,7 @@
     "semver": "^7.5.4",
     "tar": "^6.2.0",
     "tmp": "^0.2.1",
+    "ts-essentials": "^9.4.1",
     "tslog": "^4.9.2",
     "xml2js": "^0.6.2",
     "xpath-ts2": "^1.4.2"

package/benchmark/benchmark-slicer.js

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

package/core/pipeline-executor.js

@@ -1,221 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PipelineExecutor = void 0;
-const assert_1 = require("../util/assert");
-/**
- * The pipeline executor allows to execute arbitrary {@link Pipeline|pipelines} in a step-by-step fashion.
- * If you are not yet in the possession of a {@link Pipeline|pipeline}, you can use the {@link createPipeline} function
- * to create one for yourself, based on the steps that you want to execute.
- *
- * Those steps are split into two phases or "stages" (which is the name that we will use in the following), represented
- * by the {@link PipelineStepStage} type. These allow us to separate things that have to be done
- * once per-file, e.g., actually parsing the AST, from those, that we need to repeat 'once per request' (whatever this
- * request may be). In other words, what can be cached between operations and what can not.
- *
- * Furthermore, this executor follows an iterable fashion to be *as flexible as possible*
- * (e.g., to be instrumented with measurements). So, you can use the pipeline executor like this:
- *
- * ```ts
- * const stepper = new PipelineExecutor( ... )
- * while(stepper.hasNextStep()) {
- *     await stepper.nextStep()
- * }
- *
- * stepper.switchToRequestStage()
- *
- * while(stepper.hasNextStep()) {
- *     await stepper.nextStep()
- * }
- *
- * const result = stepper.getResults()
- * ```
- *
- * Of course, you might think, that this is rather overkill if you simply want to receive the result.
- * And this is true. Therefore, if you do not want to perform some kind of magic in-between steps, you can use the
- * **{@link allRemainingSteps}** function like this:
- *
- * ```ts
- * const stepper = new PipelineExecutor( ... )
- * const result = await stepper.allRemainingSteps()
- * ```
- *
- * As the name suggest, you can combine this name with previous calls to {@link nextStep} to only execute the remaining
- * steps in case, for whatever reason you only want to instrument some steps.
- *
- * By default, the {@link PipelineExecutor} does not offer an automatic way to repeat requests (mostly to prevent accidental errors).
- * However, you can use the
- * **{@link updateRequest}** function to reset the request steps and re-execute them for a new request. This allows something like the following:
- *
- * ```ts
- * const stepper = new PipelineExecutor( ... )
- * const result = await stepper.allRemainingSteps()
- *
- * stepper.updateRequest( ... )
- * const result2 = await stepper.allRemainingSteps()
- * ```
- *
- * **Example - Slicing With the Pipeline Executor**:
- *
- * Suppose, you want to... you know _slice_ a file (which was, at one point the origin of flowR), then you can
- * either create a pipeline yourself with the respective steps, or you can use the {@link DEFAULT_SLICING_PIPELINE} (and friends).
- * With it, slicing essentially becomes 'easy-as-pie':
- *
- * ```ts
- * const slicer = new PipelineExecutor(DEFAULT_SLICING_PIPELINE, {
- *    shell:     new RShell(),
- *    // of course, the criterion and request given here are just examples, you can use whatever you want to slice!
- *    criterion: ['2@b'],
- *    request:   requestFromInput('b <- 3; x <- 5\ncat(b)'),
- * })
- * const result = await slicer.allRemainingSteps()
- * ```
- *
- * But now, we want to slice for `x` in the first line as well! We can do that by adding:
- *
- * ```ts
- * stepper.updateRequest({ criterion: ['1@x'] })
- * const result2 = await stepper.allRemainingSteps()
- * ```
- *
- * @note Even though using the pipeline executor introduces a small performance overhead, we consider
- * it to be the baseline for performance benchmarking. It may very well be possible to squeeze out a little bit more by
- * directly constructing the steps in the right order. However, we consider this to be negligible when compared with the time required
- * for, for example, the dataflow analysis of larger files.
- *
- * @see PipelineExecutor#allRemainingSteps
- * @see PipelineExecutor#nextStep
- */
-class PipelineExecutor {
-    pipeline;
-    length;
-    input;
-    output = {};
-    currentExecutionStage = 0 /* PipelineStepStage.OncePerFile */;
-    stepCounter = 0;
-    /**
-     * Construct a new pipeline executor.
-     * The required additional input is specified by the {@link IPipelineStep#requiredInput|required input configuration} of each step in the `pipeline`.
-     *
-     * @param pipeline - The {@link Pipeline} to execute, probably created with {@link createPipeline}.
-     * @param input    - External {@link PipelineInput|configuration and input} required to execute the given pipeline.
-     */
-    constructor(pipeline, input) {
-        this.pipeline = pipeline;
-        this.length = pipeline.order.length;
-        this.input = input;
-    }
-    /**
-     * Retrieve the current {@link PipelineStepStage|stage} the pipeline executor is in.
-     *
-     * @see currentExecutionStage
-     * @see switchToRequestStage
-     * @see PipelineStepStage
-     */
-    getCurrentStage() {
-        return this.currentExecutionStage;
-    }
-    /**
-     * Switch to the next {@link PipelineStepStage|stage} of the pipeline executor.
-     *
-     * This will fail if either a step change is currently not valid (as not all steps have been executed),
-     * or if there is no next stage (i.e., the pipeline is already completed or in the last stage).
-     *
-     * @see PipelineExecutor
-     * @see getCurrentStage
-     */
-    switchToRequestStage() {
-        (0, assert_1.guard)(this.stepCounter === this.pipeline.firstStepPerRequest, 'First need to complete all steps before switching');
-        (0, assert_1.guard)(this.currentExecutionStage === 0 /* PipelineStepStage.OncePerFile */, 'Cannot switch to next stage, already in per-request stage.');
-        this.currentExecutionStage = 1 /* PipelineStepStage.OncePerRequest */;
-    }
-    /**
-     * Returns the results of the pipeline.
-     *
-     * @param intermediate - Normally you can only receive the results *after* the stepper completed the step of interested.
-     * 		 However, if you pass `true` to this parameter, you can also receive the results *before* the {@link PipelineExecutor|pipeline executor}
-     * 		 completed, although the typing system then can not guarantee which of the steps have already happened.
-     */
-    getResults(intermediate = false) {
-        (0, assert_1.guard)(intermediate || this.stepCounter >= this.length, 'Without the intermediate flag, the pipeline must be completed before providing access to the results.');
-        return this.output;
-    }
-    /**
-     * Returns true only if
-     * 1) there are more {@link IPipelineStep|steps} to-do for the current {@link PipelineStepStage|stage} and
-     * 2) we have not yet reached the end of the {@link Pipeline|pipeline}.
-     */
-    hasNextStep() {
-        return (this.stepCounter < this.length && this.currentExecutionStage !== 0 /* PipelineStepStage.OncePerFile */)
-            || this.stepCounter < this.pipeline.firstStepPerRequest;
-    }
-    /**
-     * Execute the next {@link IPipelineStep|step} and return the name of the {@link IPipelineStep|step} that was executed,
-     * so you can guard if the {@link IPipelineStep|step} differs from what you are interested in.
-     * Furthermore, it returns the {@link IPipelineStep|step's} result.
-     *
-     * @param expectedStepName - A safeguard if you want to retrieve the result.
-     * 												   If given, it causes the execution to fail if the next step is not the one you expect.
-     *
-     * _Without `expectedStepName`, please refrain from accessing the result, as you have no safeguards if the pipeline changes._
-     */
-    async nextStep(expectedStepName) {
-        const [step, result] = this._doNextStep(expectedStepName);
-        const awaitedResult = await result;
-        this.output[step] = awaitedResult;
-        this.stepCounter++;
-        return { name: step, result: awaitedResult };
-    }
-    _doNextStep(expectedStepName) {
-        const step = this.pipeline.steps.get(this.pipeline.order[this.stepCounter]);
-        (0, assert_1.guard)(step !== undefined, () => `Cannot execute next step, step ${this.pipeline.order[this.stepCounter]} does not exist.`);
-        if (expectedStepName !== undefined) {
-            (0, assert_1.guard)(step.name === expectedStepName, () => `Cannot execute next step, expected step ${JSON.stringify(expectedStepName)} but got ${step.name}.`);
-        }
-        return [step.name, step.processor(this.output, this.input)];
-    }
-    /**
-     * This only makes sense if you have already run a request and want to re-use the per-file results for a new one.
-     * (or if for whatever reason you did not pass information for the pipeline with the constructor).
-     *
-     * @param newRequestData - Data for the new request
-     */
-    updateRequest(newRequestData) {
-        const requestStep = this.pipeline.firstStepPerRequest;
-        (0, assert_1.guard)(this.stepCounter >= requestStep, 'Cannot reset request prior to once-per-request stage');
-        this.input = {
-            ...this.input,
-            ...newRequestData
-        };
-        this.stepCounter = requestStep;
-        // clear the results for all steps with an index >= firstStepPerRequest, this is more of a sanity check
-        for (let i = requestStep; i < this.length; i++) {
-            this.output[this.pipeline.order[i]] = undefined;
-        }
-    }
-    /**
-     * Execute all remaining steps and automatically call {@link switchToRequestStage} if necessary.
-     * @param canSwitchStage - If true, automatically switch to the request stage if necessary
-     *       (i.e., this is what you want if you have never executed {@link nextStep} and you want to execute *all* steps).
-     *       However, passing false allows you to only execute the steps of the 'once-per-file' stage (i.e., the steps that can be cached).
-     *
-     * @note There is a small type difference if you pass 'false' and already have manually switched to the 'once-per-request' stage.
-     *       Because now, the results of these steps are no longer part of the result type (although they are still included).
-     *       In such a case, you may be better off with simply passing 'true' as the function will detect that the stage is already switched.
-     *       We could solve this type problem by separating the {@link PipelineExecutor} class into two for each stage,
-     *       but this would break the improved readability and unified handling of the executor that I wanted to achieve with this class.
-     */
-    async allRemainingSteps(canSwitchStage = true) {
-        while (this.hasNextStep()) {
-            await this.nextStep();
-        }
-        if (canSwitchStage && this.stepCounter < this.length && this.currentExecutionStage === 0 /* PipelineStepStage.OncePerFile */) {
-            this.switchToRequestStage();
-            while (this.hasNextStep()) {
-                await this.nextStep();
-            }
-        }
-        return this.stepCounter < this.length ? this.getResults(true) : this.getResults();
-    }
-}
-exports.PipelineExecutor = PipelineExecutor;
-//# sourceMappingURL=pipeline-executor.js.map

package/core/stepping-slicer.js

@@ -1,160 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SteppingSlicer = void 0;
-const steps_1 = require("./steps");
-const pipeline_1 = require("./steps/pipeline");
-const _00_parse_1 = require("./steps/all/core/00-parse");
-const _10_normalize_1 = require("./steps/all/core/10-normalize");
-const _20_dataflow_1 = require("./steps/all/core/20-dataflow");
-const _00_slice_1 = require("./steps/all/static-slicing/00-slice");
-const _10_reconstruct_1 = require("./steps/all/static-slicing/10-reconstruct");
-const pipeline_executor_1 = require("./pipeline-executor");
-const legacyPipelines = {
-    // brrh, but who cares, it is legacy!
-    'parse': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP),
-    'normalize': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE),
-    'dataflow': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.LEGACY_STATIC_DATAFLOW),
-    'slice': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.LEGACY_STATIC_DATAFLOW, _00_slice_1.STATIC_SLICE),
-    'reconstruct': (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.LEGACY_STATIC_DATAFLOW, _00_slice_1.STATIC_SLICE, _10_reconstruct_1.NAIVE_RECONSTRUCT)
-};
-function getLegacyPipeline(interestedIn) {
-    return legacyPipelines[interestedIn];
-}
-/**
- * This is ultimately the root of flowR's static slicing procedure.
- * It clearly defines the steps that are to be executed and splits them into two stages.
- * - `once-per-file`: for steps that are executed once per file. These can be performed *without* the knowledge of a slicing criteria,
- *   and they can be cached and re-used if you want to slice the same file multiple times.
- * - `once-per-slice`: for steps that are executed once per slice. These can only be performed *with* a slicing criteria.
- *
- * Furthermore, this stepper follows an iterable fashion to be *as flexible as possible* (e.g., to be instrumented with measurements).
- * So, you can use the stepping slicer like this:
- *
- * ```ts
- * const slicer = new SteppingSlicer({ ... })
- * while(slicer.hasNextStep()) {
- *     await slicer.nextStep()
- * }
- *
- * slicer.switchToSliceStage()
- *
- * while(slicer.hasNextStep()) {
- *     await slicer.nextStep()
- * }
- *
- * const result = slicer.getResults()
- * ```
- *
- * Of course, you might think, that this is rather overkill if you simply want to receive the slice of a given input source or in general
- * the result of any step. And this is true. Therefore, if you do not want to perform some kind of magic in-between steps, you can use the
- * **{@link allRemainingSteps}** function like this:
- *
- * ```ts
- * const slicer = new SteppingSlicer({ ... })
- * const result = await slicer.allRemainingSteps()
- * ```
- *
- * As the name suggest, you can combine this name with previous calls to {@link nextStep} to only execute the remaining steps.
- *
- * Giving the **step of interest** allows you to declare the maximum step to execute.
- * So, if you pass `dataflow` as the step of interest, the stepping slicer will stop after the dataflow step.
- * If you do not pass a step, the stepping slicer will execute all steps.
- *
- * By default, the {@link SteppingSlicer} does not offer an automatic way to repeat the per-slice steps for multiple slices (this is mostly to prevent accidental errors).
- * However, you can use the **{@link updateCriterion}** function to reset the per-slice steps and re-execute them for a new slice. This allows something like the following:
- *
- * ```ts
- * const slicer = new SteppingSlicer({ ... })
- * const result = await slicer.allRemainingSteps()
- *
- * slicer.updateCriterion(...)
- * const result2 = await slicer.allRemainingSteps()
- * ```
- *
- * @note Even though, using the stepping slicer introduces some performance overhead, we consider
- * it to be the baseline for performance benchmarking. It may very well be possible to squeeze out some more performance by
- * directly constructing the steps in the right order. However, we consider this to be negligible when compared with the time required
- * for, for example, the dataflow analysis.
- *
- * @see retrieveResultOfStep
- * @see StepName
- */
-class SteppingSlicer {
-    executor;
-    /**
-     * Create a new stepping slicer. For more details on the arguments please see {@link SteppingSlicerInput}.
-     */
-    constructor(input) {
-        this.executor = new pipeline_executor_1.PipelineExecutor(getLegacyPipeline(input.stepOfInterest ?? steps_1.LAST_STEP), input);
-    }
-    /**
-     * Retrieve the current stage the stepping slicer is in.
-     * @see PipelineStepStage
-     * @see switchToSliceStage
-     */
-    getCurrentStage() {
-        return this.executor.getCurrentStage();
-    }
-    /**
-     * Switch to the next stage of the stepping slicer.
-     * @see SteppingSlicer
-     * @see getCurrentStage
-     */
-    switchToSliceStage() {
-        this.executor.switchToRequestStage();
-    }
-    /**
-     * Returns the result of the step of interest, as well as the results of all steps before it.
-     *
-     * @param intermediate - normally you can only receive the results *after* the stepper completed the step of interested.
-     * 		 However, if you pass `true` to this parameter, you can also receive the results *before* the step of interest,
-     * 		 although the typing system then can not guarantee which of the steps have already happened.
-     */
-    getResults(intermediate = false) {
-        return this.executor.getResults(intermediate);
-    }
-    /**
-     * Returns true only if 1) there are more steps to-do for the current stage and 2) we have not yet reached the step we are interested in
-     */
-    hasNextStep() {
-        return this.executor.hasNextStep();
-    }
-    /**
-     * Execute the next step (guarded with {@link hasNextStep}) and return the name of the step that was executed, so you can guard if the step differs from what you are interested in.
-     * Furthermore, it returns the step's result.
-     *
-     * The `step` parameter is a safeguard if you want to retrieve the result.
-     * If given, it causes the execution to fail if the next step is not the one you expect.
-     * *Without step, please refrain from accessing the result.*
-     */
-    async nextStep(expectedStepName) {
-        return this.executor.nextStep(expectedStepName);
-    }
-    /**
-     * This only makes sense if you have already sliced a file (e.g., by running up to the `slice` step) and want to do so again while caching the results.
-     * Or if for whatever reason you did not pass a criterion with the constructor.
-     *
-     * @param newCriterion - the new slicing criterion to use for the next slice
-     */
-    updateCriterion(newCriterion) {
-        // @ts-expect-error -- it is legacy
-        this.executor.updateRequest({ criterion: newCriterion });
-    }
-    /**
-     * Execute all remaining steps and automatically call {@link switchToSliceStage} if necessary.
-     * @param canSwitchStage - if true, automatically switch to the slice stage if necessary
-     *       (i.e., this is what you want if you have never executed {@link nextStep} and you want to execute *all* steps).
-     *       However, passing false allows you to only execute the steps of the 'once-per-file' stage (i.e., the steps that can be cached).
-     *
-     * @note There is a small type difference if you pass 'false' and already have manually switched to the 'once-per-slice' stage.
-     *       Because now, the results of these steps are no longer part of the result type (although they are still included).
-     *       In such a case, you may be better off with simply passing 'true' as the function will detect that the stage is already switched.
-     *       We could solve this type problem by separating the SteppingSlicer class into two for each stage, but this would break the improved readability and unified handling
-     *       of the slicer that I wanted to achieve with this class.
-     */
-    async allRemainingSteps(canSwitchStage = true) {
-        return this.executor.allRemainingSteps(canSwitchStage);
-    }
-}
-exports.SteppingSlicer = SteppingSlicer;
-//# sourceMappingURL=stepping-slicer.js.map

package/core/steps/all/00-parse.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PARSE_WITH_R_SHELL_STEP = void 0;
-const print_1 = require("../../print/print");
-const parse_printer_1 = require("../../print/parse-printer");
-const r_bridge_1 = require("../../../r-bridge");
-exports.PARSE_WITH_R_SHELL_STEP = {
-    name: 'parse',
-    description: 'Parse the given R code into an AST',
-    processor: r_bridge_1.retrieveXmlFromRCode,
-    required: 'once-per-file',
-    printer: {
-        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
-        [2 /* StepOutputFormat.Json */]: text => text,
-        [5 /* StepOutputFormat.RdfQuads */]: parse_printer_1.parseToQuads
-    },
-    dependencies: []
-};
-//# sourceMappingURL=00-parse.js.map