@eagleoutice/flowr 1.5.2 → 2.0.1

package/core/steps/all/static-slicing/10-reconstruct.d.ts

@@ -0,0 +1,25 @@
+import { internalPrinter } from '../../../print/print';
+import { PipelineStepStage } from '../../pipeline-step';
+import type { SliceResult } from '../../../../slicing/static/slicer-types';
+import type { AutoSelectPredicate } from '../../../../reconstruct/reconstruct';
+import type { NormalizedAst } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export interface ReconstructRequiredInput {
+    autoSelectIf?: AutoSelectPredicate;
+}
+declare function processor(results: {
+    normalize?: NormalizedAst;
+    slice?: SliceResult;
+}, input: Partial<ReconstructRequiredInput>): import("../../../../reconstruct/reconstruct").ReconstructionResult;
+export declare const NAIVE_RECONSTRUCT: {
+    readonly name: "reconstruct";
+    readonly humanReadableName: "static code reconstruction";
+    readonly description: "Reconstruct R code from the static slice";
+    readonly processor: typeof processor;
+    readonly executed: PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof internalPrinter;
+    };
+    readonly dependencies: readonly ["slice"];
+    readonly requiredInput: ReconstructRequiredInput;
+};
+export {};

package/core/steps/all/static-slicing/10-reconstruct.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NAIVE_RECONSTRUCT = void 0;
+const print_1 = require("../../../print/print");
+const reconstruct_1 = require("../../../../reconstruct/reconstruct");
+function processor(results, input) {
+    return (0, reconstruct_1.reconstructToCode)(results.normalize, results.slice.result, input.autoSelectIf);
+}
+exports.NAIVE_RECONSTRUCT = {
+    name: 'reconstruct',
+    humanReadableName: 'static code reconstruction',
+    description: 'Reconstruct R code from the static slice',
+    processor,
+    executed: 1 /* PipelineStepStage.OncePerRequest */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+    },
+    dependencies: ['slice'],
+    requiredInput: undefined
+};
+//# sourceMappingURL=10-reconstruct.js.map

package/core/steps/pipeline/create-pipeline.d.ts

@@ -0,0 +1,6 @@
+import type { IPipelineStep } from '../pipeline-step';
+import type { Pipeline } from './pipeline';
+/**
+ * Given a set of {@link IPipelineStep|steps} with their dependencies, this function verifies all requirements of {@link createPipeline}.
+ */
+export declare function verifyAndBuildPipeline(steps: readonly IPipelineStep[]): Pipeline;

package/core/steps/pipeline/create-pipeline.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAndBuildPipeline = void 0;
+const invalid_pipeline_error_1 = require("./invalid-pipeline-error");
+const json_1 = require("../../../util/json");
+const arrays_1 = require("../../../util/arrays");
+/**
+ * Given a set of {@link IPipelineStep|steps} with their dependencies, this function verifies all requirements of {@link createPipeline}.
+ */
+function verifyAndBuildPipeline(steps) {
+    if (steps.length === 0) {
+        throw new invalid_pipeline_error_1.InvalidPipelineError('0) Pipeline is empty');
+    }
+    const [perFileSteps, perRequestSteps] = (0, arrays_1.partitionArray)(steps, s => s.executed === 0 /* PipelineStepStage.OncePerFile */);
+    // we construct a map linking each name to its respective step
+    const perFileStepMap = new Map();
+    const initsPerFile = [];
+    const visited = new Set();
+    // we start by working on the per-file steps
+    initializeSteps(perFileSteps, perFileStepMap, initsPerFile, visited);
+    // first, we sort the per-file steps
+    const sortedPerFile = topologicalSort(initsPerFile, perFileStepMap, visited);
+    validateStepOutput(sortedPerFile, perFileStepMap, steps);
+    const perRequestStepMap = new Map(perFileStepMap);
+    // we track all elements without dependencies, i.e., those that start the pipeline
+    const initsPerRequest = [];
+    // now, we do the same for the per-request steps, keeping the per-file steps known
+    initializeSteps(perRequestSteps, perRequestStepMap, initsPerRequest, visited);
+    const sortedPerRequest = topologicalSort(initsPerRequest, perRequestStepMap, visited);
+    const sorted = [...sortedPerFile, ...sortedPerRequest];
+    validateStepOutput(sorted, perRequestStepMap, steps);
+    return {
+        steps: perRequestStepMap,
+        order: sorted,
+        firstStepPerRequest: sortedPerFile.length
+    };
+}
+exports.verifyAndBuildPipeline = verifyAndBuildPipeline;
+function validateStepOutput(sorted, stepMap, steps) {
+    if (sorted.length !== stepMap.size) {
+        // check if any of the dependencies in the map are invalid
+        checkForInvalidDependency(steps, stepMap);
+        // otherwise, we assume a cycle
+        throw new invalid_pipeline_error_1.InvalidPipelineError(`3) Pipeline contains at least one cycle; sorted: ${JSON.stringify(sorted)}, steps: ${JSON.stringify([...stepMap.keys()])}`);
+    }
+}
+function allDependenciesAreVisited(step, visited) {
+    return step.dependencies.every(d => visited.has(d));
+}
+function handleStep(step, init, visited, sorted, elem, decoratorsOfLastOthers, inits) {
+    if (step.decorates === init) {
+        if (allDependenciesAreVisited(step, visited)) {
+            sorted.push(elem);
+            visited.add(elem);
+        }
+        else {
+            decoratorsOfLastOthers.add(elem);
+        }
+    }
+    else if (step.decorates === undefined && allDependenciesAreVisited(step, visited)) {
+        inits.push(elem);
+    }
+}
+function topologicalSort(inits, stepMap, visited) {
+    const sorted = [];
+    while (inits.length > 0) {
+        const init = inits.pop();
+        sorted.push(init);
+        visited.add(init);
+        // these decorators still have dependencies open; we have to check if they can be satisfied by the other steps to add
+        const decoratorsOfLastOthers = new Set();
+        for (const [elem, step] of stepMap.entries()) {
+            if (visited.has(elem)) {
+                continue;
+            }
+            handleStep(step, init, visited, sorted, elem, decoratorsOfLastOthers, inits);
+        }
+        // for the other decorators we have to cycle until we find a solution, or know, that no solution exists
+        topologicallyInsertDecoratorElements(decoratorsOfLastOthers, stepMap, visited, sorted);
+    }
+    return sorted;
+}
+function topologicallyInsertDecoratorElements(decoratorsOfLastOthers, stepMap, visited, sorted) {
+    if (decoratorsOfLastOthers.size === 0) {
+        return;
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const elem of [...decoratorsOfLastOthers]) {
+            const step = stepMap.get(elem);
+            if (allDependenciesAreVisited(step, visited)) {
+                decoratorsOfLastOthers.delete(elem);
+                sorted.push(elem);
+                visited.add(elem);
+                changed = true;
+            }
+        }
+    }
+    if (decoratorsOfLastOthers.size > 0) {
+        throw new invalid_pipeline_error_1.InvalidPipelineError(`5) Pipeline contains at least one decoration cycle: ${JSON.stringify(decoratorsOfLastOthers, json_1.jsonReplacer)}`);
+    }
+}
+function checkForInvalidDependency(steps, stepMap) {
+    for (const step of steps) {
+        for (const dep of step.dependencies) {
+            if (!stepMap.has(dep)) {
+                throw new invalid_pipeline_error_1.InvalidPipelineError(`2) Step "${step.name}" depends on step "${dep}" which does not exist`);
+            }
+        }
+        if (step.decorates && !stepMap.has(step.decorates)) {
+            throw new invalid_pipeline_error_1.InvalidPipelineError(`4) Step "${step.name}" decorates step "${step.decorates}" which does not exist`);
+        }
+    }
+}
+function initializeSteps(steps, stepMap, inits, visited) {
+    for (const step of steps) {
+        const name = step.name;
+        // if the name is already in the map, we have a duplicate
+        if (stepMap.has(name)) {
+            throw new invalid_pipeline_error_1.InvalidPipelineError(`1) Step name "${name}" is not unique in the pipeline`);
+        }
+        stepMap.set(name, step);
+        // only steps that have no dependencies and do not decorate others can be initial steps
+        if (allDependenciesAreVisited(step, visited) && (step.decorates === undefined || visited.has(step.decorates))) {
+            inits.push(name);
+        }
+    }
+}
+//# sourceMappingURL=create-pipeline.js.map

package/core/steps/pipeline/default-pipelines.d.ts

@@ -0,0 +1,251 @@
+export declare const DEFAULT_SLICING_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "parse";
+    readonly humanReadableName: "parse with R shell";
+    readonly description: "Parse the given R code into an AST";
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => import("ts-essentials").AsyncOrSync<string>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: (text: string) => string;
+        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+    };
+    readonly dependencies: readonly [];
+    readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
+} | {
+    readonly name: "normalize";
+    readonly humanReadableName: "normalize";
+    readonly description: "Normalize the AST to flowR's AST";
+    readonly processor: (results: {
+        parse?: string | undefined;
+    }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: typeof import("../../print/normalize-printer").normalizedAstToJson;
+        readonly 5: typeof import("../../print/normalize-printer").normalizedAstToQuads;
+        readonly 3: typeof import("../../print/normalize-printer").printNormalizedAstToMermaid;
+        readonly 4: typeof import("../../print/normalize-printer").printNormalizedAstToMermaidUrl;
+    };
+    readonly dependencies: readonly ["parse"];
+    readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
+} | {
+    readonly humanReadableName: "dataflow";
+    readonly processor: (results: {
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+    }, input: {
+        request?: import("../../../r-bridge/retriever").RParseRequest | undefined;
+    }) => import("../../../dataflow/info").DataflowInformation;
+    readonly requiredInput: {};
+    readonly name: "dataflow";
+    readonly description: "Construct the dataflow graph";
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: typeof import("../../print/dataflow-printer").dataflowGraphToJson;
+        readonly 5: typeof import("../../print/dataflow-printer").dataflowGraphToQuads;
+        readonly 3: typeof import("../../print/dataflow-printer").dataflowGraphToMermaid;
+        readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
+    };
+    readonly dependencies: readonly ["normalize"];
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation | undefined;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
+    readonly name: "reconstruct";
+    readonly humanReadableName: "static code reconstruction";
+    readonly description: "Reconstruct R code from the static slice";
+    readonly processor: (results: {
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+        slice?: import("../../../slicing/static/slicer-types").SliceResult | undefined;
+    }, input: Partial<import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput>) => import("../../../reconstruct/reconstruct").ReconstructionResult;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["slice"];
+    readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
+}>;
+export declare const DEFAULT_RECONSTRUCT_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "parse";
+    readonly humanReadableName: "parse with R shell";
+    readonly description: "Parse the given R code into an AST";
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => import("ts-essentials").AsyncOrSync<string>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: (text: string) => string;
+        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+    };
+    readonly dependencies: readonly [];
+    readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
+} | {
+    readonly name: "normalize";
+    readonly humanReadableName: "normalize";
+    readonly description: "Normalize the AST to flowR's AST";
+    readonly processor: (results: {
+        parse?: string | undefined;
+    }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: typeof import("../../print/normalize-printer").normalizedAstToJson;
+        readonly 5: typeof import("../../print/normalize-printer").normalizedAstToQuads;
+        readonly 3: typeof import("../../print/normalize-printer").printNormalizedAstToMermaid;
+        readonly 4: typeof import("../../print/normalize-printer").printNormalizedAstToMermaidUrl;
+    };
+    readonly dependencies: readonly ["parse"];
+    readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
+} | {
+    readonly humanReadableName: "dataflow";
+    readonly processor: (results: {
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+    }, input: {
+        request?: import("../../../r-bridge/retriever").RParseRequest | undefined;
+    }) => import("../../../dataflow/info").DataflowInformation;
+    readonly requiredInput: {};
+    readonly name: "dataflow";
+    readonly description: "Construct the dataflow graph";
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: typeof import("../../print/dataflow-printer").dataflowGraphToJson;
+        readonly 5: typeof import("../../print/dataflow-printer").dataflowGraphToQuads;
+        readonly 3: typeof import("../../print/dataflow-printer").dataflowGraphToMermaid;
+        readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
+    };
+    readonly dependencies: readonly ["normalize"];
+} | {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: (results: {
+        dataflow?: import("../../../dataflow/info").DataflowInformation | undefined;
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+    }, input: Partial<import("../all/static-slicing/00-slice").SliceRequiredInput>) => Readonly<import("../../../slicing/static/slicer-types").SliceResult>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: import("../all/static-slicing/00-slice").SliceRequiredInput;
+} | {
+    readonly name: "reconstruct";
+    readonly humanReadableName: "static code reconstruction";
+    readonly description: "Reconstruct R code from the static slice";
+    readonly processor: (results: {
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+        slice?: import("../../../slicing/static/slicer-types").SliceResult | undefined;
+    }, input: Partial<import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput>) => import("../../../reconstruct/reconstruct").ReconstructionResult;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+    };
+    readonly dependencies: readonly ["slice"];
+    readonly requiredInput: import("../all/static-slicing/10-reconstruct").ReconstructRequiredInput;
+}>;
+export declare const DEFAULT_DATAFLOW_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "parse";
+    readonly humanReadableName: "parse with R shell";
+    readonly description: "Parse the given R code into an AST";
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => import("ts-essentials").AsyncOrSync<string>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: (text: string) => string;
+        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+    };
+    readonly dependencies: readonly [];
+    readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
+} | {
+    readonly name: "normalize";
+    readonly humanReadableName: "normalize";
+    readonly description: "Normalize the AST to flowR's AST";
+    readonly processor: (results: {
+        parse?: string | undefined;
+    }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: typeof import("../../print/normalize-printer").normalizedAstToJson;
+        readonly 5: typeof import("../../print/normalize-printer").normalizedAstToQuads;
+        readonly 3: typeof import("../../print/normalize-printer").printNormalizedAstToMermaid;
+        readonly 4: typeof import("../../print/normalize-printer").printNormalizedAstToMermaidUrl;
+    };
+    readonly dependencies: readonly ["parse"];
+    readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
+} | {
+    readonly humanReadableName: "dataflow";
+    readonly processor: (results: {
+        normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>> | undefined;
+    }, input: {
+        request?: import("../../../r-bridge/retriever").RParseRequest | undefined;
+    }) => import("../../../dataflow/info").DataflowInformation;
+    readonly requiredInput: {};
+    readonly name: "dataflow";
+    readonly description: "Construct the dataflow graph";
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: typeof import("../../print/dataflow-printer").dataflowGraphToJson;
+        readonly 5: typeof import("../../print/dataflow-printer").dataflowGraphToQuads;
+        readonly 3: typeof import("../../print/dataflow-printer").dataflowGraphToMermaid;
+        readonly 4: typeof import("../../print/dataflow-printer").dataflowGraphToMermaidUrl;
+    };
+    readonly dependencies: readonly ["normalize"];
+}>;
+export declare const DEFAULT_NORMALIZE_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "parse";
+    readonly humanReadableName: "parse with R shell";
+    readonly description: "Parse the given R code into an AST";
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => import("ts-essentials").AsyncOrSync<string>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: (text: string) => string;
+        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+    };
+    readonly dependencies: readonly [];
+    readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
+} | {
+    readonly name: "normalize";
+    readonly humanReadableName: "normalize";
+    readonly description: "Normalize the AST to flowR's AST";
+    readonly processor: (results: {
+        parse?: string | undefined;
+    }, input: Partial<import("../all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: typeof import("../../print/normalize-printer").normalizedAstToJson;
+        readonly 5: typeof import("../../print/normalize-printer").normalizedAstToQuads;
+        readonly 3: typeof import("../../print/normalize-printer").printNormalizedAstToMermaid;
+        readonly 4: typeof import("../../print/normalize-printer").printNormalizedAstToMermaidUrl;
+    };
+    readonly dependencies: readonly ["parse"];
+    readonly requiredInput: import("../all/core/10-normalize").NormalizeRequiredInput;
+}>;
+export declare const DEFAULT_PARSE_PIPELINE: import("./pipeline").Pipeline<{
+    readonly name: "parse";
+    readonly humanReadableName: "parse with R shell";
+    readonly description: "Parse the given R code into an AST";
+    readonly processor: (_results: unknown, input: Partial<import("../all/core/00-parse").ParseRequiredInput>) => import("ts-essentials").AsyncOrSync<string>;
+    readonly executed: import("../pipeline-step").PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof import("../../print/print").internalPrinter;
+        readonly 2: (text: string) => string;
+        readonly 5: typeof import("../../print/parse-printer").parseToQuads;
+    };
+    readonly dependencies: readonly [];
+    readonly requiredInput: import("../all/core/00-parse").ParseRequiredInput;
+}>;

package/core/steps/pipeline/default-pipelines.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PARSE_PIPELINE = exports.DEFAULT_NORMALIZE_PIPELINE = exports.DEFAULT_DATAFLOW_PIPELINE = exports.DEFAULT_RECONSTRUCT_PIPELINE = exports.DEFAULT_SLICING_PIPELINE = void 0;
+/**
+ * Contains the default pipeline for working with flowr
+ */
+const pipeline_1 = require("./pipeline");
+const _00_parse_1 = require("../all/core/00-parse");
+const _10_normalize_1 = require("../all/core/10-normalize");
+const _20_dataflow_1 = require("../all/core/20-dataflow");
+const _00_slice_1 = require("../all/static-slicing/00-slice");
+const _10_reconstruct_1 = require("../all/static-slicing/10-reconstruct");
+exports.DEFAULT_SLICING_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.STATIC_DATAFLOW, _00_slice_1.STATIC_SLICE, _10_reconstruct_1.NAIVE_RECONSTRUCT);
+exports.DEFAULT_RECONSTRUCT_PIPELINE = exports.DEFAULT_SLICING_PIPELINE;
+exports.DEFAULT_DATAFLOW_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE, _20_dataflow_1.STATIC_DATAFLOW);
+exports.DEFAULT_NORMALIZE_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, _10_normalize_1.NORMALIZE);
+exports.DEFAULT_PARSE_PIPELINE = (0, pipeline_1.createPipeline)(_00_parse_1.PARSE_WITH_R_SHELL_STEP);
+//# sourceMappingURL=default-pipelines.js.map

package/core/steps/pipeline/invalid-pipeline-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Thrown if for whatever reason, the pipeline is invalid.
+ */
+export declare class InvalidPipelineError extends Error {
+    constructor(message: string);
+}

package/core/steps/pipeline/invalid-pipeline-error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidPipelineError = void 0;
+/**
+ * Thrown if for whatever reason, the pipeline is invalid.
+ */
+class InvalidPipelineError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidPipelineError';
+    }
+}
+exports.InvalidPipelineError = InvalidPipelineError;
+//# sourceMappingURL=invalid-pipeline-error.js.map

package/core/steps/pipeline/pipeline.d.ts

@@ -0,0 +1,60 @@
+import type { IPipelineStep, PipelineStepName, PipelineStepStage } from '../pipeline-step';
+import type { DeepReadonly, UnionToIntersection } from 'ts-essentials';
+/**
+ * A pipeline is a collection of {@link Pipeline#steps|steps} that are executed in a certain {@link Pipeline#order|order}.
+ * It is to be created {@link createPipeline}.
+ *
+ * If you want to get the type of all steps in the pipeline (given they are created canonically using const step names), refer to {@link PipelineStepNames}.
+ */
+export interface Pipeline<T extends IPipelineStep = IPipelineStep> {
+    readonly steps: ReadonlyMap<PipelineStepName, DeepReadonly<IPipelineStep>>;
+    readonly order: readonly T['name'][];
+    /**
+     * In the order, this is the index of the first step that
+     * is executed {@link PipelineStepStage#OncePerRequest|once per request}.
+     * If it is "out of bounds" (i.e., the number of steps), all steps are executed {@link PipelineStepStage#OncePerFile|once per file}.
+     */
+    readonly firstStepPerRequest: number;
+}
+/**
+ * Returns the types of all step names in the given pipeline.
+ *
+ * @see Pipeline for details
+ */
+export type PipelineStepNames<P extends Pipeline> = PipelineStep<P>['name'];
+export type PipelineStep<P extends Pipeline> = P extends Pipeline<infer U> ? U : never;
+export type PipelineStepWithName<P extends Pipeline, Name extends PipelineStepName> = P extends Pipeline<infer U> ? U extends IPipelineStep<Name> ? U : never : never;
+export type PipelineStepProcessorWithName<P extends Pipeline, Name extends PipelineStepName> = PipelineStepWithName<P, Name>['processor'];
+export type PipelineStepPrintersWithName<P extends Pipeline, Name extends PipelineStepName> = PipelineStepWithName<P, Name>['printer'];
+export type PipelineStepOutputWithName<P extends Pipeline, Name extends PipelineStepName> = Awaited<ReturnType<PipelineStepProcessorWithName<P, Name>>>;
+export type PipelineInput<P extends Pipeline> = UnionToIntersection<PipelineStep<P>['requiredInput']>;
+/**
+ * Only gets the union of 'requiredInput' of those PipelineSteps which have a 'execute' field of type 'OncePerRequest'.
+ * In other words, information that you may want to change for another request (e.g., another slice) with the same file.
+ */
+export type PipelinePerRequestInput<P extends Pipeline> = {
+    [K in PipelineStepNames<P>]: PipelineStepWithName<P, K>['executed'] extends PipelineStepStage.OncePerFile ? never : PipelineStepWithName<P, K>['requiredInput'];
+}[PipelineStepNames<P>];
+export type PipelineOutput<P extends Pipeline> = {
+    [K in PipelineStepNames<P>]: PipelineStepOutputWithName<P, K>;
+};
+/**
+ * Creates a {@link Pipeline|pipeline} from a given collection of {@link IPipelineStep|steps}.
+ * In order to be valid, the collection of {@link IPipelineStep|steps} must satisfy the following set of constraints
+ * (which should be logical, when you consider what a pipeline should accomplish):
+ *
+ * 0) the collection of {@link IPipelineStep|steps} is not empty
+ * 1) all {@link IPipelineStepOrder#name|names} of {@link IPipelineStep|steps} are unique for the given pipeline
+ * 2) all {@link IPipelineStepOrder#dependencies|dependencies} of all {@link IPipelineStep|steps} are exist
+ * 3) there are no cycles in the dependency graph
+ * 4) the target of a {@link IPipelineStepOrder#decorates|step's decoration} exists
+ * 5) if a {@link IPipelineStepOrder#decorates|decoration} applies, all of its {@link IPipelineStepOrder#dependencies|dependencies} are already in the pipeline
+ * 6) in the resulting {@link Pipeline|pipeline}, there is a strict cut between {@link IPipelineStep|steps} that are executed
+ * 		{@link PipelineStepStage#OncePerFile|once per file} and {@link PipelineStepStage#OncePerRequest|once per request}.
+ *
+ * @returns The function will try to order your collection steps so that all the constraints hold.
+ * If it succeeds it will return the resulting {@link Pipeline|pipeline}, otherwise it will throw an {@link InvalidPipelineError}.
+ *
+ * @throws InvalidPipelineError If any of the constraints listed above are not satisfied.
+ */
+export declare function createPipeline<T extends readonly IPipelineStep[]>(...steps: T): Pipeline<T[number]>;

package/core/steps/pipeline/pipeline.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipeline = void 0;
+const create_pipeline_1 = require("./create-pipeline");
+/**
+ * Creates a {@link Pipeline|pipeline} from a given collection of {@link IPipelineStep|steps}.
+ * In order to be valid, the collection of {@link IPipelineStep|steps} must satisfy the following set of constraints
+ * (which should be logical, when you consider what a pipeline should accomplish):
+ *
+ * 0) the collection of {@link IPipelineStep|steps} is not empty
+ * 1) all {@link IPipelineStepOrder#name|names} of {@link IPipelineStep|steps} are unique for the given pipeline
+ * 2) all {@link IPipelineStepOrder#dependencies|dependencies} of all {@link IPipelineStep|steps} are exist
+ * 3) there are no cycles in the dependency graph
+ * 4) the target of a {@link IPipelineStepOrder#decorates|step's decoration} exists
+ * 5) if a {@link IPipelineStepOrder#decorates|decoration} applies, all of its {@link IPipelineStepOrder#dependencies|dependencies} are already in the pipeline
+ * 6) in the resulting {@link Pipeline|pipeline}, there is a strict cut between {@link IPipelineStep|steps} that are executed
+ * 		{@link PipelineStepStage#OncePerFile|once per file} and {@link PipelineStepStage#OncePerRequest|once per request}.
+ *
+ * @returns The function will try to order your collection steps so that all the constraints hold.
+ * If it succeeds it will return the resulting {@link Pipeline|pipeline}, otherwise it will throw an {@link InvalidPipelineError}.
+ *
+ * @throws InvalidPipelineError If any of the constraints listed above are not satisfied.
+ */
+function createPipeline(...steps) {
+    return (0, create_pipeline_1.verifyAndBuildPipeline)(steps);
+}
+exports.createPipeline = createPipeline;
+//# sourceMappingURL=pipeline.js.map