@eagleoutice/flowr 1.5.2 → 2.0.1

package/util/objects.js

@@ -38,6 +38,10 @@ function deepMergeObject(base, addon) {
 exports.deepMergeObject = deepMergeObject;
 function deepMergeObjectWithResult(addon, base, result) {
     for (const key of Object.keys(addon)) {
+        // values that are undefined (like from a partial object) should NOT be overwritten
+        if (addon[key] === undefined) {
+            continue;
+        }
         if (typeof addon[key] === 'object') {
             if (key in base) {
                 result[key] = deepMergeObject(base[key], addon[key]);

package/util/quads.d.ts

@@ -8,7 +8,7 @@
  * @module
  */
 import type { MergeableRecord } from './objects';
-import type { NodeId } from '../r-bridge';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 type RecordForQuad = Record<string, unknown>;
 type DataForQuad = Record<string, unknown> | ArrayLike<unknown>;
 type ContextForQuad = string;
@@ -20,8 +20,8 @@ type ContextForQuad = string;
 export type QuadIgnoreIf = (key: string, value: unknown) => boolean;
 /**
  * Deterministically retrieve a unique id for a given object.
- * @param obj - the object to retrieve the id for
- * @param context - In order to provide unique ids even for different contexts, we add the context to the id.
+ * @param obj - The object to retrieve the id for
+ * @param context - to provide unique ids even for different contexts, we add the context to the id.
  */
 export type QuadIdRetriever = (obj: unknown, context: ContextForQuad) => string;
 /**

package/util/quads.js

@@ -176,7 +176,6 @@ function serializeObject(obj, quads, config) {
     else if (obj instanceof Set) {
         let i = 0;
         for (const value of obj.values()) {
-            console.log('set', value);
             processObjectEntry('idx-' + String(i++), value, obj, quads, config);
         }
     }

package/util/range.d.ts

@@ -1,32 +1,45 @@
-export interface SourcePosition {
+export type SourcePosition = [
     /** starts with 1 */
-    line: number;
+    line: number,
     /** starts with 1 */
-    column: number;
-}
-export interface SourceRange {
+    column: number
+];
+export type SourceRange = [
     /** inclusive start position */
-    readonly start: SourcePosition;
+    startLine: number,
+    startColumn: number,
     /** inclusive end position */
-    readonly end: SourcePosition;
-}
+    endLine: number,
+    endColumn: number
+];
+export declare function getRangeStart(p: undefined): undefined;
+export declare function getRangeStart(p: SourceRange): SourcePosition;
+export declare function getRangeStart(p: SourceRange | undefined): SourcePosition | undefined;
+export declare function getRangeEnd(p: undefined): undefined;
+export declare function getRangeEnd(p: SourceRange): SourcePosition;
+export declare function getRangeEnd(p: SourceRange | undefined): SourcePosition | undefined;
 /**
- * at the moment this does not ensure ordering of start and end!
+ * This does not ensure ordering of start and end!
+ *
+ * @param sl - start line
+ * @param sc - start column
+ * @param el - end line
+ * @param ec - end column
  */
-export declare function rangeFrom(line1: number | string, col1: number | string, line2: number | string, col2: number | string): SourceRange;
+export declare function rangeFrom(sl: number | string, sc: number | string, el: number | string, ec: number | string): SourceRange;
 export declare function mergeRanges(...rs: SourceRange[]): SourceRange;
 /**
  * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
  */
-export declare function rangeStartsCompletelyBefore(r1: SourceRange, r2: SourceRange): boolean;
+export declare function rangeStartsCompletelyBefore([, , r1el, r1ec]: SourceRange, [r2sl, r2sc, ,]: SourceRange): boolean;
 /**
  * Checks if the two ranges overlap.
  */
-export declare function rangesOverlap(r1: SourceRange, r2: SourceRange): boolean;
-export declare function addRanges(r1: SourceRange, r2: SourceRange): SourceRange;
+export declare function rangesOverlap([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): boolean;
+export declare function addRanges([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): SourceRange;
 /**
  * Provides a comparator for {@link SourceRange}s that sorts them in ascending order.
  *
  * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
  */
-export declare function rangeCompare(r1: SourceRange, r2: SourceRange): number;
+export declare function rangeCompare([r1sl, r1sc, ,]: SourceRange, [r2sl, r2sc, ,]: SourceRange): number;

package/util/range.js

@@ -1,47 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rangeCompare = exports.addRanges = exports.rangesOverlap = exports.rangeStartsCompletelyBefore = exports.mergeRanges = exports.rangeFrom = void 0;
+exports.rangeCompare = exports.addRanges = exports.rangesOverlap = exports.rangeStartsCompletelyBefore = exports.mergeRanges = exports.rangeFrom = exports.getRangeEnd = exports.getRangeStart = void 0;
 const assert_1 = require("./assert");
+function getRangeStart(p) {
+    return p === undefined ? undefined : [p[0], p[1]];
+}
+exports.getRangeStart = getRangeStart;
+function getRangeEnd(p) {
+    return p === undefined ? undefined : [p[2], p[3]];
+}
+exports.getRangeEnd = getRangeEnd;
 /**
- * at the moment this does not ensure ordering of start and end!
+ * This does not ensure ordering of start and end!
+ *
+ * @param sl - start line
+ * @param sc - start column
+ * @param el - end line
+ * @param ec - end column
  */
-function rangeFrom(line1, col1, line2, col2) {
-    return {
-        start: {
-            line: Number(line1),
-            column: Number(col1)
-        },
-        end: {
-            line: Number(line2),
-            column: Number(col2)
-        }
-    };
+function rangeFrom(sl, sc, el, ec) {
+    return [Number(sl), Number(sc), Number(el), Number(ec)];
 }
 exports.rangeFrom = rangeFrom;
 function mergeRanges(...rs) {
     (0, assert_1.guard)(rs.length > 0, 'Cannot merge no ranges');
-    return {
-        start: rs.reduce((acc, r) => acc.line < r.start.line || (acc.line === r.start.line && acc.column < r.start.column) ? acc : r.start, rs[0].start),
-        end: rs.reduce((acc, r) => acc.line > r.end.line || (acc.line === r.end.line && acc.column > r.end.column) ? acc : r.end, rs[0].end)
-    };
+    return rs.reduce(([sl, sc, el, ec], [nsl, nsc, nel, nec]) => [
+        ...(sl < nsl || (sl === nsl && sc < nsc) ? [sl, sc] : [nsl, nsc]),
+        ...(el > nel || (el === nel && ec > nec) ? [el, ec] : [nel, nec])
+    ], rs[0]);
 }
 exports.mergeRanges = mergeRanges;
 /**
  * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
  */
-function rangeStartsCompletelyBefore(r1, r2) {
-    return r1.end.line < r2.start.line || (r1.end.line === r2.start.line && r1.end.column < r2.start.column);
+function rangeStartsCompletelyBefore([, , r1el, r1ec], [r2sl, r2sc, ,]) {
+    return r1el < r2sl || (r1el === r2sl && r1ec < r2sc);
 }
 exports.rangeStartsCompletelyBefore = rangeStartsCompletelyBefore;
 /**
  * Checks if the two ranges overlap.
  */
-function rangesOverlap(r1, r2) {
-    return r1.start.line <= r2.end.line && r2.start.line <= r1.end.line && r1.start.column <= r2.end.column && r2.start.column <= r1.end.column;
+function rangesOverlap([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
+    return r1sl <= r2el && r2sl <= r1el && r1sc <= r2ec && r2sc <= r1ec;
 }
 exports.rangesOverlap = rangesOverlap;
-function addRanges(r1, r2) {
-    return rangeFrom(r1.start.line + r2.start.line, r1.start.column + r2.start.column, r1.end.line + r2.end.line, r1.end.column + r2.end.column);
+function addRanges([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
+    return [r1sl + r2sl, r1sc + r2sc, r1el + r2el, r1ec + r2ec];
 }
 exports.addRanges = addRanges;
 /**
@@ -49,12 +53,12 @@ exports.addRanges = addRanges;
  *
  * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
  */
-function rangeCompare(r1, r2) {
-    if (r1.start.line === r2.start.line) {
-        return r1.start.column - r2.start.column;
+function rangeCompare([r1sl, r1sc, ,], [r2sl, r2sc, ,]) {
+    if (r1sl === r2sl) {
+        return r1sc - r2sc;
     }
     else {
-        return r1.start.line - r2.start.line;
+        return r1sl - r2sl;
     }
 }
 exports.rangeCompare = rangeCompare;

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = void 0;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '1.5.2';
+const version = '2.0.1';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }

package/core/index.d.ts

@@ -1,4 +0,0 @@
-export { SteppingSlicer } from './slicer';
-export * from './steps';
-export * from './input';
-export * from './output';

package/core/index.js

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

package/core/input.d.ts

@@ -1,42 +0,0 @@
-import type { MergeableRecord } from '../util/objects';
-import type { IdGenerator, NoInfo, RParseRequest, RShell, XmlParserHooks } from '../r-bridge';
-import type { DeepPartial } from 'ts-essentials';
-import type { AutoSelectPredicate, SlicingCriteria } from '../slicing';
-import type { STEPS_PER_SLICE, StepName, STEPS_PER_FILE } from './steps';
-/**
- * We split the types, as if you are only interested in what can be done per-file, you do not need a slicing criterion.
- * Furthermore, if you are only interested in the parse result, you do not require the token map and you can not pass hooks
- */
-interface BaseSteppingSlicerInput<InterestedIn extends StepName | undefined> extends MergeableRecord {
-    /**
-     * The step you are actually interested in.
-     * If you pass 'dataflow', the stepper will stop after analyzing the dataflow.
-     * The step is optional, if you do not pass a step, the stepper will execute all steps.
-     */
-    stepOfInterest?: InterestedIn;
-    /** This is the {@link RShell} connection to be used to obtain the original parses AST of the R code */
-    shell: RShell;
-    /** The request which essentially indicates the input to extract the AST from */
-    request: RParseRequest;
-    /** These hooks only make sense if you at least want to normalize the parsed R AST. They can augment the normalization process */
-    hooks?: DeepPartial<XmlParserHooks>;
-    /** This id generator is only necessary if you want to retrieve a dataflow from the parsed R AST, it determines the id generator to use and by default uses the {@link deterministicCountingIdGenerator}*/
-    getId?: IdGenerator<NoInfo>;
-    /** The slicing criterion is only of interest if you actually want to slice the R code */
-    criterion?: SlicingCriteria;
-    /** If you want to auto-select something in the reconstruction add it here, otherwise, it will use the default defined alongside {@link reconstructToCode}*/
-    autoSelectIf?: AutoSelectPredicate;
-}
-interface NormalizeSteppingSlicerInput<InterestedIn extends 'dataflow' | 'normalize'> extends BaseSteppingSlicerInput<InterestedIn> {
-    stepOfInterest: InterestedIn;
-}
-interface SliceSteppingSlicerInput<InterestedIn extends 'reconstruct' | 'slice' | undefined> extends BaseSteppingSlicerInput<InterestedIn> {
-    stepOfInterest?: InterestedIn;
-    criterion: SlicingCriteria;
-}
-/**
- * For a given set of steps of interest, this essentially (statically) determines the required inputs for the {@link SteppingSlicer}.
- * All arguments are documented alongside {@link BaseSteppingSlicerInput}.
- */
-export type SteppingSlicerInput<InterestedIn extends StepName | undefined = undefined> = InterestedIn extends keyof typeof STEPS_PER_SLICE | undefined ? SliceSteppingSlicerInput<InterestedIn> : InterestedIn extends Exclude<keyof typeof STEPS_PER_FILE, 'parse'> ? NormalizeSteppingSlicerInput<InterestedIn> : BaseSteppingSlicerInput<InterestedIn>;
-export {};

package/core/output.d.ts

@@ -1,15 +0,0 @@
-import type { LAST_STEP, StepName, StepResult } from './steps';
-/** Represents the return value of the processor linked to the step with the name 'K' */
-type Out<K extends StepName> = Record<K, StepResult<K>>;
-/**
- * Essentially expresses an object that, if a step 'x' is of interest, contains the result of step 'x' and all steps before 'x'.
- */
-export type StepResults<InterestedIn extends StepName | undefined> = InterestedIn extends never ? never : InterestedIn extends undefined ? StepResultsHelper<typeof LAST_STEP> : StepResultsHelper<Exclude<InterestedIn, undefined>>;
-type StepResultsHelper<InterestedIn extends StepName> = {
-    'parse': Out<'parse'>;
-    'normalize': StepResultsHelper<'parse'> & Out<'normalize'>;
-    'dataflow': StepResultsHelper<'normalize'> & Out<'dataflow'>;
-    'slice': StepResultsHelper<'dataflow'> & Out<'slice'>;
-    'reconstruct': StepResultsHelper<'slice'> & Out<'reconstruct'>;
-}[InterestedIn];
-export {};

package/core/slicer.d.ts

@@ -1,124 +0,0 @@
-import type { LAST_PER_FILE_STEP, StepRequired, StepName, StepResult } from './steps';
-import { LAST_STEP, STEPS_PER_SLICE } from './steps';
-import type { SlicingCriteria } from '../slicing';
-import type { SteppingSlicerInput } from './input';
-import type { StepResults } from './output';
-/**
- * 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 SteppingSlicer#doNextStep
- * @see StepName
- */
-export declare class SteppingSlicer<InterestedIn extends StepName | undefined = typeof LAST_STEP> {
-    static readonly maximumNumberOfStepsPerFile: number;
-    static readonly maximumNumberOfStepsPerSlice: number;
-    private readonly shell;
-    private readonly stepOfInterest;
-    private readonly request;
-    private readonly hooks?;
-    private readonly getId?;
-    private criterion?;
-    private results;
-    private stage;
-    private stepCounter;
-    private reachedWanted;
-    /**
-     * Create a new stepping slicer. For more details on the arguments please see {@link SteppingSlicerInput}.
-     */
-    constructor(input: SteppingSlicerInput<InterestedIn>);
-    /**
-     * Retrieve the current stage the stepping slicer is in.
-     * @see StepRequired
-     * @see switchToSliceStage
-     */
-    getCurrentStage(): StepRequired;
-    /**
-     * Switch to the next stage of the stepping slicer.
-     * @see SteppingSlicer
-     * @see getCurrentStage
-     */
-    switchToSliceStage(): void;
-    getResults(intermediate?: false): StepResults<InterestedIn>;
-    getResults(intermediate: true): Partial<StepResults<InterestedIn>>;
-    /**
-     * 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(): boolean;
-    /**
-     * 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.*
-     */
-    nextStep<PassedName extends StepName>(expectedStepName?: PassedName): Promise<{
-        name: typeof expectedStepName extends undefined ? StepName : PassedName;
-        result: typeof expectedStepName extends undefined ? unknown : StepResult<Exclude<PassedName, undefined>>;
-    }>;
-    private getGuardStep;
-    private doNextStep;
-    /**
-     * 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: SlicingCriteria): void;
-    allRemainingSteps(canSwitchStage: false): Promise<Partial<StepResults<InterestedIn extends keyof typeof STEPS_PER_SLICE | undefined ? typeof LAST_PER_FILE_STEP : InterestedIn>>>;
-    allRemainingSteps(canSwitchStage?: true): Promise<StepResults<InterestedIn>>;
-}

package/core/slicer.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SteppingSlicer = void 0;
-const steps_1 = require("./steps");
-const assert_1 = require("../util/assert");
-/**
- * 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 SteppingSlicer#doNextStep
- * @see StepName
- */
-class SteppingSlicer {
-    static maximumNumberOfStepsPerFile = Object.keys(steps_1.STEPS_PER_FILE).length;
-    static maximumNumberOfStepsPerSlice = SteppingSlicer.maximumNumberOfStepsPerFile + Object.keys(steps_1.STEPS_PER_SLICE).length;
-    shell;
-    stepOfInterest;
-    request;
-    hooks;
-    getId;
-    criterion;
-    results = {};
-    stage = 'once-per-file';
-    stepCounter = 0;
-    reachedWanted = false;
-    /**
-     * Create a new stepping slicer. For more details on the arguments please see {@link SteppingSlicerInput}.
-     */
-    constructor(input) {
-        this.shell = input.shell;
-        this.request = input.request;
-        this.hooks = input.hooks;
-        this.getId = input.getId;
-        this.stepOfInterest = (input.stepOfInterest ?? steps_1.LAST_STEP);
-        this.criterion = input.criterion;
-    }
-    /**
-     * Retrieve the current stage the stepping slicer is in.
-     * @see StepRequired
-     * @see switchToSliceStage
-     */
-    getCurrentStage() {
-        return this.stage;
-    }
-    /**
-     * Switch to the next stage of the stepping slicer.
-     * @see SteppingSlicer
-     * @see getCurrentStage
-     */
-    switchToSliceStage() {
-        (0, assert_1.guard)(this.stepCounter === SteppingSlicer.maximumNumberOfStepsPerFile, 'First need to complete all steps before switching');
-        (0, assert_1.guard)(this.stage === 'once-per-file', 'Cannot switch to next stage, already in once-per-slice stage');
-        this.stage = 'once-per-slice';
-    }
-    /**
-     * 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) {
-        (0, assert_1.guard)(intermediate || this.reachedWanted, 'Before reading the results, we need to reach the step we are interested in');
-        return this.results;
-    }
-    /**
-     * 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.reachedWanted && (this.stage === 'once-per-file' ?
-            this.stepCounter < SteppingSlicer.maximumNumberOfStepsPerFile
-            : this.stepCounter < SteppingSlicer.maximumNumberOfStepsPerSlice);
-    }
-    /**
-     * 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) {
-        (0, assert_1.guard)(this.hasNextStep(), 'No more steps to do');
-        const guardStep = this.getGuardStep(expectedStepName);
-        const { step, result } = await this.doNextStep(guardStep);
-        this.results[step] = result;
-        this.stepCounter += 1;
-        if (this.stepOfInterest === step) {
-            this.reachedWanted = true;
-        }
-        return { name: step, result: result };
-    }
-    getGuardStep(expectedStepName) {
-        return expectedStepName === undefined ?
-            (name) => name
-            :
-                (name) => {
-                    (0, assert_1.guard)(expectedStepName === name, `Expected step ${expectedStepName} but got ${name}`);
-                    return name;
-                };
-    }
-    async doNextStep(guardStep) {
-        let step;
-        let result;
-        switch (this.stepCounter) {
-            case 0:
-                step = guardStep('parse');
-                result = await (0, steps_1.executeSingleSubStep)(step, this.request, this.shell);
-                break;
-            case 1:
-                step = guardStep('normalize');
-                result = (0, steps_1.executeSingleSubStep)(step, this.results.parse, this.hooks, this.getId);
-                break;
-            case 2:
-                step = guardStep('dataflow');
-                result = (0, steps_1.executeSingleSubStep)(step, this.request, this.results.normalize);
-                break;
-            case 3:
-                (0, assert_1.guard)(this.criterion !== undefined, 'Cannot decode criteria without a criterion');
-                step = guardStep('slice');
-                result = (0, steps_1.executeSingleSubStep)(step, this.results.dataflow.graph, this.results.normalize, this.criterion);
-                break;
-            case 4:
-                step = guardStep('reconstruct');
-                result = (0, steps_1.executeSingleSubStep)(step, this.results.normalize, this.results.slice.result);
-                break;
-            default:
-                throw new Error(`Unknown step ${this.stepCounter}, reaching this should not happen!`);
-        }
-        return { step, result };
-    }
-    /**
-     * 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) {
-        (0, assert_1.guard)(this.stepCounter >= SteppingSlicer.maximumNumberOfStepsPerFile, 'Cannot reset slice prior to once-per-slice stage');
-        this.criterion = newCriterion;
-        this.stepCounter = SteppingSlicer.maximumNumberOfStepsPerFile;
-        this.results.slice = undefined;
-        this.results.reconstruct = undefined;
-        if (this.stepOfInterest === 'slice' || this.stepOfInterest === 'reconstruct') {
-            this.reachedWanted = false;
-        }
-    }
-    /**
-     * 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) {
-        while (this.hasNextStep()) {
-            await this.nextStep();
-        }
-        if (canSwitchStage && !this.reachedWanted && this.stage === 'once-per-file') {
-            this.switchToSliceStage();
-            while (this.hasNextStep()) {
-                await this.nextStep();
-            }
-        }
-        return this.reachedWanted ? this.getResults() : this.getResults(true);
-    }
-}
-exports.SteppingSlicer = SteppingSlicer;
-//# sourceMappingURL=slicer.js.map